v15.0.0

Prepare changelog for v15.0.0
v15.0.0-rc.1
2021-10-25 11:22:22 +01:00 · 2021-10-25 11:22:21 +01:00 · 2021-10-19 10:50:42 +01:00 · 2021-10-19 10:50:41 +01:00 · 2021-10-15 14:32:19 +01:00 · 2021-10-15 14:32:13 +01:00
62 changed files with 4536 additions and 3407 deletions
@@ -1,3 +1,102 @@
+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).
+
+## ✨ 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).
+
+## 🐛 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)
+=============================================================================================================
+
+## 🚨 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).
+
+## ✨ 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).
+
+## 🐛 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)
+===================================================================================================
+
+## 🚨 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).
+
+## ✨ 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).
+
+## 🐛 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 [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).
+
+## ✨ 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).
+
+## 🐛 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)
+===================================================================================================
+
+## ✨ 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)).
+
+## 🐛 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)
+=============================================================================================================
+
+## ✨ 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)).
+
+## 🐛 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)
 ===================================================================================================

@@ -10,16 +109,12 @@ Changes in [12.5.0](https://github.com/vector-im/element-desktop/releases/tag/v1
 ## 🐛 Bug Fixes
 * Fix verification request cancellation ([\#1871](https://github.com/matrix-org/matrix-js-sdk/pull/1871)).

-Changes in [12.5.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v12.5.0-rc.1) (2021-09-07)
-=============================================================================================================
+Changes in [12.4.1](https://github.com/vector-im/element-desktop/releases/tag/v12.4.1) (2021-09-13)
+===================================================================================================

-## ✨ Features
- * 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)).
+## 🔒 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)
 ===================================================================================================
@@ -22,8 +22,14 @@ ask you to make any refinements needed or merge it and make them ourselves.
 Things that should go into your PR description:
 * A changelog entry in the `Notes` section (see below)
 * References to any bugs fixed by the change (in GitHub's `Fixes` notation)
- * Notes for the reviewer that might help them to understand why the change is
-   necessary or how they might better review it.
+ * Describe the why and what is changing in the PR description so it's easy for
+   onlookers and reviewers to onboard and context switch.
+ * Include both **before** and **after** screenshots to easily compare and discuss
+   what's changing.
+ * Include a step-by-step testing strategy so that a reviewer can check out the
+   code locally and easily get to the point of testing your change.
+ * Add comments to the diff for the reviewer that might help them to understand
+   why the change is necessary or how they might better understand and review it.

 Things that should *not* go into your PR description:
 * Any information on how the code works or why you chose to do it the way
@@ -92,6 +98,21 @@ We use continuous integration, and all pull requests get automatically tested:
 if your change breaks the build, then the PR will show that there are failed
 checks, so please check back after a few minutes.

+Tests
+-----
+If your PR is a feature (ie. if it's being labelled with the 'T-Enhancement'
+label) then we require that the PR also includes tests. These need to test that
+your feature works as expected and ideally test edge cases too. For the js-sdk
+itself, your tests should generally be unit tests. matrix-react-sdk also uses
+these guidelines, so for that your tests can be unit tests using
+react-test-utils, snapshot tests or screenshot tests.
+
+We don't require tests for bug fixes (T-Defect) but strongly encourage regression
+tests for the bug itself wherever possible.
+
+In the future we may formalise this more with a minimum test coverage
+percentage for the diff.
+
 Code style
 ----------
 The js-sdk aims to target TypeScript/ES6. All new files should be written in
@@ -1,6 +1,6 @@
 {
  "name": "matrix-js-sdk",
-  "version": "12.5.0",
+  "version": "15.0.0",
  "description": "Matrix Client-Server SDK for Javascript",
  "scripts": {
    "prepublishOnly": "yarn build",
@@ -246,7 +246,7 @@ describe("OlmDevice", function() {

            // 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);
+            expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);

            const task2 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
                aliceOlmDevice, baseApis, devicesByUserBA,
@@ -254,7 +254,7 @@ describe("OlmDevice", function() {

            // 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);
+            expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);

            // Track the tasks, but don't await them yet.
            const promises = Promise.all([
@@ -288,7 +288,7 @@ describe("MegolmBackup", function() {
                                        ed25519: "SENDER_ED25519",
                                    },
                                    room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice._pickleKey),
+                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
                                },
                                txn);
                        });
@@ -369,7 +369,7 @@ describe("MegolmBackup", function() {
                                        ed25519: "SENDER_ED25519",
                                    },
                                    room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice._pickleKey),
+                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
                                },
                                txn);
                        });
@@ -546,7 +546,7 @@ describe("MegolmBackup", function() {
                                        ed25519: "SENDER_ED25519",
                                    },
                                    room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice._pickleKey),
+                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
                                },
                                txn);
                        });
@@ -69,7 +69,7 @@ describe("verification request integration tests with crypto layer", function()
            bobVerifier.verify();

            // XXX: Private function access (but it's a test, so we're okay)
-            bobVerifier._endTimer();
+            bobVerifier.endTimer();
        });
        const aliceRequest = await alice.client.requestVerification("@bob:example.com");
        await aliceRequest.waitFor(r => r.started);
@@ -77,6 +77,6 @@ describe("verification request integration tests with crypto layer", function()
        expect(aliceVerifier).toBeInstanceOf(SAS);

        // XXX: Private function access (but it's a test, so we're okay)
-        aliceVerifier._endTimer();
+        aliceVerifier.endTimer();
    });
 });
@@ -93,7 +93,7 @@ describe("self-verifications", () => {
            undefined, // startEvent
            request,
        );
-        verification._resolve = () => undefined;
+        verification.resolve = () => undefined;

        const result = await verification.done();

@@ -14,21 +14,25 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { MatrixClient } from "../../../src";
+import { IContent, MatrixClient, MatrixEvent } from "../../../src";
 import { Room } from "../../../src/models/room";
-import { UNSTABLE_MSC3089_BRANCH } from "../../../src/@types/event";
+import { IEncryptedFile, RelationType, UNSTABLE_MSC3089_BRANCH } from "../../../src/@types/event";
 import { EventTimelineSet } from "../../../src/models/event-timeline-set";
 import { EventTimeline } from "../../../src/models/event-timeline";
 import { MSC3089Branch } from "../../../src/models/MSC3089Branch";
+import { MSC3089TreeSpace } from "../../../src/models/MSC3089TreeSpace";

 describe("MSC3089Branch", () => {
    let client: MatrixClient;
    // @ts-ignore - TS doesn't know that this is a type
    let indexEvent: any;
+    let directory: MSC3089TreeSpace;
    let branch: MSC3089Branch;
+    let branch2: MSC3089Branch;

    const branchRoomId = "!room:example.org";
    const fileEventId = "$file";
+    const fileEventId2 = "$second_file";

    const staticTimelineSets = {} as EventTimelineSet;
    const staticRoom = {
@@ -50,7 +54,12 @@ describe("MSC3089Branch", () => {
            getRoomId: () => branchRoomId,
            getStateKey: () => fileEventId,
        });
-        branch = new MSC3089Branch(client, indexEvent);
+        directory = new MSC3089TreeSpace(client, branchRoomId);
+        branch = new MSC3089Branch(client, indexEvent, directory);
+        branch2 = new MSC3089Branch(client, {
+            getRoomId: () => branchRoomId,
+            getStateKey: () => fileEventId2,
+        } as MatrixEvent, directory);
    });

    it('should know the file event ID', () => {
@@ -69,13 +78,15 @@ describe("MSC3089Branch", () => {
    });

    it('should be able to delete the file', async () => {
+        const eventIdOrder = [fileEventId, fileEventId2];
+
        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(stateKey).toEqual(fileEventId);
+                expect(stateKey).toEqual(eventIdOrder[stateFn.mock.calls.length - 1]);

                return Promise.resolve(); // return value not used
            });
@@ -83,16 +94,19 @@ describe("MSC3089Branch", () => {

        const redactFn = jest.fn().mockImplementation((roomId: string, eventId: string) => {
            expect(roomId).toEqual(branchRoomId);
-            expect(eventId).toEqual(fileEventId);
+            expect(eventId).toEqual(eventIdOrder[stateFn.mock.calls.length - 1]);

            return Promise.resolve(); // return value not used
        });
        client.redactEvent = redactFn;

+        branch.getVersionHistory = () => Promise.resolve([branch, branch2]);
+        branch2.getVersionHistory = () => Promise.resolve([branch2]);
+
        await branch.delete();

-        expect(stateFn).toHaveBeenCalledTimes(1);
-        expect(redactFn).toHaveBeenCalledTimes(1);
+        expect(stateFn).toHaveBeenCalledTimes(2);
+        expect(redactFn).toHaveBeenCalledTimes(2);
    });

    it('should know its name', async () => {
@@ -127,16 +141,71 @@ describe("MSC3089Branch", () => {
        expect(stateFn).toHaveBeenCalledTimes(1);
    });

+    it('should be v1 by default', () => {
+        indexEvent.getContent = () => ({ active: true });
+
+        const res = branch.version;
+
+        expect(res).toEqual(1);
+    });
+
+    it('should be vN when set', () => {
+        indexEvent.getContent = () => ({ active: true, version: 3 });
+
+        const res = branch.version;
+
+        expect(res).toEqual(3);
+    });
+
+    it('should be unlocked by default', async () => {
+        indexEvent.getContent = () => ({ active: true });
+
+        const res = branch.isLocked();
+
+        expect(res).toEqual(false);
+    });
+
+    it('should use lock status from index event', async () => {
+        indexEvent.getContent = () => ({ active: true, locked: true });
+
+        const res = branch.isLocked();
+
+        expect(res).toEqual(true);
+    });
+
+    it('should be able to change its locked status', async () => {
+        const locked = true;
+        indexEvent.getContent = () => ({ active: true, retained: true });
+        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({
+                    retained: true, // canary for copying state
+                    active: true,
+                    locked: locked,
+                });
+                expect(stateKey).toEqual(fileEventId);
+
+                return Promise.resolve(); // return value not used
+            });
+        client.sendStateEvent = stateFn;
+
+        await branch.setLocked(locked);
+
+        expect(stateFn).toHaveBeenCalledTimes(1);
+    });
+
    it('should be able to return event information', async () => {
        const mxcLatter = "example.org/file";
        const fileContent = { isFile: "not quite", url: "mxc://" + mxcLatter };
-        const eventsArr = [
-            { getId: () => "$not-file", getContent: () => ({}) },
-            { getId: () => fileEventId, getContent: () => ({ file: fileContent }) },
-        ];
-        client.getEventTimeline = () => Promise.resolve({
-            getEvents: () => eventsArr,
-        }) as any as Promise<EventTimeline>; // partial
+        const fileEvent = { getId: () => fileEventId, getOriginalContent: () => ({ file: fileContent }) };
+        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}`;
@@ -151,4 +220,113 @@ describe("MSC3089Branch", () => {
            httpUrl: expect.stringMatching(`.+${mxcLatter.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`),
        });
    });
+
+    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;
+        client.mxcUrlToHttp = (mxc: string) => {
+            expect(mxc).toEqual("mxc://" + mxcLatter);
+            return `https://example.org/_matrix/media/v1/download/${mxcLatter}`;
+        };
+        client.decryptEventIfNeeded = () => Promise.resolve();
+
+        const res = await branch.getFileEvent();
+        expect(res).toBeDefined();
+        expect(res).toBe(fileEvent);
+    });
+
+    it('should create new versions of itself', async () => {
+        const canaryName = "canary";
+        const fileContents = "contents go here";
+        const canaryContents = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));
+        const canaryFile = {} as IEncryptedFile;
+        const canaryAddl = { canary: true };
+        indexEvent.getContent = () => ({ active: true, retained: true });
+        const stateKeyOrder = [fileEventId2, fileEventId];
+        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(stateKey).toEqual(stateKeyOrder[stateFn.mock.calls.length - 1]);
+                if (stateKey === fileEventId) {
+                    expect(content).toMatchObject({
+                        retained: true, // canary for copying state
+                        active: false,
+                    });
+                } else if (stateKey === fileEventId2) {
+                    expect(content).toMatchObject({
+                        active: true,
+                        version: 2,
+                        name: canaryName,
+                    });
+                } else {
+                    throw new Error("Unexpected state key: " + stateKey);
+                }
+
+                return Promise.resolve(); // return value not used
+            });
+        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,
+                },
+            });
+
+            return Promise.resolve({ event_id: fileEventId2 });
+        });
+        directory.createFile = createFn;
+
+        await branch.createNewVersion(canaryName, canaryContents, canaryFile, canaryAddl);
+
+        expect(stateFn).toHaveBeenCalledTimes(2);
+        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: () => null,
+            getId: () => "$unknown",
+        }];
+        staticRoom.getLiveTimeline = () => ({ getEvents: () => events }) as EventTimeline;
+
+        directory.getFile = (evId: string) => {
+            expect(evId).toEqual(fileEventId);
+            return branch;
+        };
+
+        const results = await branch2.getVersionHistory();
+        expect(results).toMatchObject([
+            branch2,
+            branch,
+        ]);
+    });
 });
@@ -227,40 +227,61 @@ describe("MSC3089TreeSpace", () => {
                        [targetUser]: expectedPl,
                    },
                });
+
+                // Store new power levels so the `getPermissions()` test passes
+                makePowerLevels(content);
+
                return Promise.resolve();
            });
        client.sendStateEvent = fn;
        await tree.setPermissions(targetUser, role);
        expect(fn.mock.calls.length).toBe(1);
+
+        const finalPermissions = tree.getPermissions(targetUser);
+        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,
+            },
        }, TreePermissions.Viewer, 1024);
    });

    it('should support setting Editor permissions', () => {
        return evaluatePowerLevels({
            ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
-            events_default: 1024,
-        }, TreePermissions.Editor, 1024);
+            users_default: 1024,
+            events_default: 1025,
+            events: {
+                [EventType.RoomPowerLevels]: 1026,
+            },
+        }, 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]: 1024,
+                [EventType.RoomPowerLevels]: 1026,
            },
-        }, TreePermissions.Owner, 1024);
+        }, 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,
            },
@@ -270,11 +291,15 @@ describe("MSC3089TreeSpace", () => {
    it('should support promoting permissions', () => {
        return evaluatePowerLevels({
            ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
-            events_default: 1024,
+            users_default: 1024,
+            events_default: 1025,
+            events: {
+                [EventType.RoomPowerLevels]: 1026,
+            },
            users: {
                [targetUser]: 5,
            },
-        }, TreePermissions.Editor, 1024);
+        }, TreePermissions.Editor, 1025);
    });

    it('should support defaults: Viewer', () => {
@@ -883,6 +908,7 @@ describe("MSC3089TreeSpace", () => {
                body: fileName,
                url: mxc,
                file: fileInfo,
+                metadata: true, // additional content from test
                [UNSTABLE_MSC3089_LEAF.unstable]: {}, // test to ensure we're definitely using unstable
            });

@@ -900,14 +926,82 @@ describe("MSC3089TreeSpace", () => {
                    name: fileName,
                });

-                return Promise.resolve(); // return value not used.
+                return Promise.resolve({ event_id: "wrong" }); // return value shouldn't be used
            });
        client.sendStateEvent = sendStateFn;

        const buf = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));

        // We clone the file info just to make sure it doesn't get mutated for the test.
-        await tree.createFile(fileName, buf, Object.assign({}, fileInfo));
+        const result = await tree.createFile(fileName, buf, Object.assign({}, fileInfo), { metadata: true });
+        expect(result).toMatchObject({ event_id: fileEventId });
+
+        expect(uploadFn).toHaveBeenCalledTimes(1);
+        expect(sendMsgFn).toHaveBeenCalledTimes(1);
+        expect(sendStateFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should upload file versions', async () => {
+        const mxc = "mxc://example.org/file";
+        const fileInfo = {
+            mimetype: "text/plain",
+            // other fields as required by encryption, but ignored here
+        };
+        const fileEventId = "$file";
+        const fileName = "My File.txt";
+        const fileContents = "This is a test file";
+
+        // Mock out Blob for the test environment
+        (<any>global).Blob = MockBlob;
+
+        const uploadFn = jest.fn().mockImplementation((contents: Blob, opts: any) => {
+            expect(contents).toBeInstanceOf(Blob);
+            expect(contents.size).toEqual(fileContents.length);
+            expect(opts).toMatchObject({
+                includeFilename: false,
+                onlyContentUri: true, // because the tests rely on this - we shouldn't really be testing  for this.
+            });
+            return Promise.resolve(mxc);
+        });
+        client.uploadContent = uploadFn;
+
+        const sendMsgFn = jest.fn().mockImplementation((roomId: string, contents: any) => {
+            expect(roomId).toEqual(tree.roomId);
+            const content = {
+                msgtype: MsgType.File,
+                body: fileName,
+                url: mxc,
+                file: fileInfo,
+            };
+            expect(contents).toMatchObject({
+                ...content,
+                "m.new_content": content,
+                [UNSTABLE_MSC3089_LEAF.unstable]: {}, // test to ensure we're definitely using unstable
+            });
+
+            return Promise.resolve({ event_id: fileEventId }); // eslint-disable-line camelcase
+        });
+        client.sendMessage = sendMsgFn;
+
+        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
+                expect(stateKey).toEqual(fileEventId);
+                expect(content).toMatchObject({
+                    active: true,
+                    name: fileName,
+                });
+
+                return Promise.resolve({ event_id: "wrong" }); // return value shouldn't be used
+            });
+        client.sendStateEvent = sendStateFn;
+
+        const buf = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));
+
+        // We clone the file info just to make sure it doesn't get mutated for the test.
+        const result = await tree.createFile(fileName, buf, Object.assign({}, fileInfo), { "m.new_content": true });
+        expect(result).toMatchObject({ event_id: fileEventId });

        expect(uploadFn).toHaveBeenCalledTimes(1);
        expect(sendMsgFn).toHaveBeenCalledTimes(1);
@@ -960,4 +1054,22 @@ describe("MSC3089TreeSpace", () => {
        expect(files.length).toEqual(1);
        expect(files[0].indexEvent).toBe(firstFile);
    });
+
+    it('should list all files', () => {
+        const firstFile = { getContent: () => ({ active: true }) };
+        const secondFile = { getContent: () => ({ active: false }) }; // deliberately inactive
+        room.currentState = {
+            getStateEvents: (eventType: string, stateKey?: string) => {
+                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test to ensure we're definitely using unstable
+                expect(stateKey).toBeUndefined();
+                return [firstFile, secondFile];
+            },
+        };
+
+        const files = tree.listAllFiles();
+        expect(files).toBeDefined();
+        expect(files.length).toEqual(2);
+        expect(files[0].indexEvent).toBe(firstFile);
+        expect(files[1].indexEvent).toBe(secondFile);
+    });
 });
@@ -1,5 +1,5 @@
 import * as utils from "../test-utils";
-import { EventStatus, MatrixEvent } from "../../src";
+import { DuplicateStrategy, EventStatus, MatrixEvent } from "../../src";
 import { EventTimeline } from "../../src/models/event-timeline";
 import { RoomState } from "../../src";
 import { Room } from "../../src";
@@ -113,7 +113,7 @@ describe("Room", function() {
            dupe.event.event_id = events[0].getId();
            room.addLiveEvents(events);
            expect(room.timeline[0]).toEqual(events[0]);
-            room.addLiveEvents([dupe], "replace");
+            room.addLiveEvents([dupe], DuplicateStrategy.Replace);
            expect(room.timeline[0]).toEqual(dupe);
        });

@@ -83,6 +83,28 @@ class MockRTCPeerConnection {
    getStats() { return []; }
 }

+class MockMediaStream {
+    constructor(
+        public id,
+    ) {}
+
+    getTracks() { return []; }
+    getAudioTracks() { return [{ enabled: true }]; }
+    getVideoTracks() { return [{ enabled: true }]; }
+    addEventListener() {}
+}
+
+class MockMediaDeviceInfo {
+    constructor(
+        public kind: "audio" | "video",
+    ) {}
+}
+
+class MockMediaHandler {
+    getUserMediaStream() { return new MockMediaStream("mock_stream_from_media_handler"); }
+    stopUserMediaStream() {}
+}
+
 describe('Call', function() {
    let client;
    let call;
@@ -98,13 +120,9 @@ describe('Call', function() {
        global.navigator = {
            mediaDevices: {
                // @ts-ignore Mock
-                getUserMedia: () => {
-                    return {
-                        getTracks: () => [],
-                        getAudioTracks: () => [],
-                        getVideoTracks: () => [],
-                    };
-                },
+                getUserMedia: () => new MockMediaStream("local_stream"),
+                // @ts-ignore Mock
+                enumerateDevices: async () => [new MockMediaDeviceInfo("audio"), new MockMediaDeviceInfo("video")],
            },
        };

@@ -115,7 +133,7 @@ describe('Call', function() {
            RTCSessionDescription: {},
            // @ts-ignore Mock
            RTCIceCandidate: {},
-            getUserMedia: {},
+            getUserMedia: () => new MockMediaStream("local_stream"),
        };
        // @ts-ignore Mock
        global.document = {};
@@ -124,6 +142,8 @@ describe('Call', function() {
        // We just stub out sendEvent: we're not interested in testing the client's
        // event sending code here
        client.client.sendEvent = () => {};
+        client.client.mediaHandler = new MockMediaHandler;
+        client.client.getMediaHandler = () => client.client.mediaHandler;
        client.httpBackend.when("GET", "/voip/turnServer").respond(200, {});
        call = new MatrixCall({
            client: client.client,
@@ -319,7 +339,7 @@ describe('Call', function() {
                        sdp: DUMMY_SDP,
                    },
                    [SDPStreamMetadataKey]: {
-                        "stream_id": {
+                        "remote_stream": {
                            purpose: SDPStreamMetadataPurpose.Usermedia,
                            audio_muted: true,
                            video_muted: false,
@@ -329,8 +349,8 @@ describe('Call', function() {
            },
        });

-        call.pushRemoteFeed({ id: "stream_id", getAudioTracks: () => ["track1"], getVideoTracks: () => ["track1"] });
-        const feed = call.getFeeds().find((feed) => feed.stream.id === "stream_id");
+        call.pushRemoteFeed(new MockMediaStream("remote_stream"));
+        const feed = call.getFeeds().find((feed) => feed.stream.id === "remote_stream");
        expect(feed?.purpose).toBe(SDPStreamMetadataPurpose.Usermedia);
        expect(feed?.isAudioMuted()).toBeTruthy();
        expect(feed?.isVideoMuted()).not.toBeTruthy();
@@ -363,4 +383,16 @@ describe('Call', function() {
        call.setScreensharingEnabled(true);
        expect(call.setScreensharingEnabledWithoutMetadataSupport).toHaveBeenCalled();
    });
+
+    it("should fallback to answering with no video", async () => {
+        await client.httpBackend.flush();
+
+        call.shouldAnswerWithMediaType = (wantedValue: boolean) => wantedValue;
+        client.client.mediaHandler.getUserMediaStream = jest.fn().mockRejectedValue("reject");
+
+        await call.answer(true, true);
+
+        expect(client.client.mediaHandler.getUserMediaStream).toHaveBeenNthCalledWith(1, true, true);
+        expect(client.client.mediaHandler.getUserMediaStream).toHaveBeenNthCalledWith(2, true, false);
+    });
 });
@@ -92,6 +92,14 @@ export enum EventType {
 export enum RelationType {
    Annotation = "m.annotation",
    Replace = "m.replace",
+    /**
+     * Note, "io.element.thread" is hardcoded
+     * Should be replaced with "m.thread" once MSC3440 lands
+     * Can not use `UnstableValue` as TypeScript does not
+     * allow computed values in enums
+     * https://github.com/microsoft/TypeScript/issues/27976
+     */
+    Thread = "io.element.thread",
 }

 export enum MsgType {
@@ -168,11 +176,6 @@ export const UNSTABLE_ELEMENT_FUNCTIONAL_USERS = new UnstableValue(
    "io.element.functional_members",
    "io.element.functional_members");

-export const UNSTABLE_ELEMENT_REPLY_IN_THREAD = new UnstableValue(
-    "m.in_thread",
-    "io.element.in_thread",
-);
-
 export interface IEncryptedFile {
    url: string;
    mimetype?: string;
@@ -33,14 +33,9 @@ declare global {
    }

    interface Window {
-        electron?: Electron;
        webkitAudioContext: typeof AudioContext;
    }

-    interface Electron {
-        getDesktopCapturerSources(options: GetSourcesOptions): Promise<Array<DesktopCapturerSource>>;
-    }
-
    interface Crypto {
        webkitSubtle?: Window["crypto"]["subtle"];
    }
@@ -67,21 +62,6 @@ declare global {
        };
    }

-    interface DesktopCapturerSource {
-        id: string;
-        name: string;
-        thumbnailURL: string;
-    }
-
-    interface GetSourcesOptions {
-        types: Array<string>;
-        thumbnailSize?: {
-            height: number;
-            width: number;
-        };
-        fetchWindowIcons?: boolean;
-    }
-
    interface HTMLAudioElement {
        // sinkId & setSinkId are experimental and typescript doesn't know about them
        sinkId: string;
@@ -108,4 +88,11 @@ declare global {
    interface PromiseConstructor {
        allSettled<T>(promises: Promise<T>[]): Promise<Array<ISettledFulfilled<T> | ISettledRejected>>;
    }
+
+    interface RTCRtpTransceiver {
+        // This has been removed from TS
+        // (https://github.com/microsoft/TypeScript-DOM-lib-generator/issues/1029),
+        // but we still need this for MatrixCall::getRidOfRTXCodecs()
+        setCodecPreferences(codecs: RTCRtpCodecCapability[]): void;
+    }
 }
@@ -82,11 +82,3 @@ export enum HistoryVisibility {
    Shared = "shared",
    WorldReadable = "world_readable",
 }
-
-// XXX move to OlmDevice when converted
-export interface InboundGroupSessionData {
-    room_id: string; // eslint-disable-line camelcase
-    session: string;
-    keysClaimed: Record<string, string>;
-    forwardingCurve25519KeyChain: string[];
-}
@@ -25,4 +25,5 @@ export interface IThreepid {
    address: string;
    validated_at: number; // eslint-disable-line camelcase
    added_at: number; // eslint-disable-line camelcase
+    bound?: boolean;
 }
@@ -17,79 +17,19 @@ limitations under the License.

 /** @module auto-discovery */

+import { IClientWellKnown, IWellKnownConfig } from "./client";
 import { logger } from './logger';
 import { URL as NodeURL } from "url";

 // Dev note: Auto discovery is part of the spec.
 // See: https://matrix.org/docs/spec/client_server/r0.4.0.html#server-discovery

-/**
- * Description for what an automatically discovered client configuration
- * would look like. Although this is a class, it is recommended that it
- * be treated as an interface definition rather than as a class.
- *
- * Additional properties than those defined here may be present, and
- * should follow the Java package naming convention.
- */
-class DiscoveredClientConfig { // eslint-disable-line no-unused-vars
-    // Dev note: this is basically a copy/paste of the .well-known response
-    // object as defined in the spec. It does have additional information,
-    // however. Overall, this exists to serve as a place for documentation
-    // and not functionality.
-    // See https://matrix.org/docs/spec/client_server/r0.4.0.html#get-well-known-matrix-client
-
-    constructor() {
-        /**
-         * The homeserver configuration the client should use. This will
-         * always be present on the object.
-         * @type {{state: string, base_url: string}} The configuration.
-         */
-        this["m.homeserver"] = {
-            /**
-             * The lookup result state. If this is anything other than
-             * AutoDiscovery.SUCCESS then base_url may be falsey. Additionally,
-             * if this is not AutoDiscovery.SUCCESS then the client should
-             * assume the other properties in the client config (such as
-             * the identity server configuration) are not valid.
-             */
-            state: AutoDiscovery.PROMPT,
-
-            /**
-             * If the state is AutoDiscovery.FAIL_ERROR or .FAIL_PROMPT
-             * then this will contain a human-readable (English) message
-             * for what went wrong. If the state is none of those previously
-             * mentioned, this will be falsey.
-             */
-            error: "Something went wrong",
-
-            /**
-             * The base URL clients should use to talk to the homeserver,
-             * particularly for the login process. May be falsey if the
-             * state is not AutoDiscovery.SUCCESS.
-             */
-            base_url: "https://matrix.org",
-        };
-
-        /**
-         * The identity server configuration the client should use. This
-         * will always be present on teh object.
-         * @type {{state: string, base_url: string}} The configuration.
-         */
-        this["m.identity_server"] = {
-            /**
-             * The lookup result state. If this is anything other than
-             * AutoDiscovery.SUCCESS then base_url may be falsey.
-             */
-            state: AutoDiscovery.PROMPT,
-
-            /**
-             * The base URL clients should use for interacting with the
-             * identity server. May be falsey if the state is not
-             * AutoDiscovery.SUCCESS.
-             */
-            base_url: "https://vector.im",
-        };
-    }
+export enum AutoDiscoveryAction {
+    SUCCESS = "SUCCESS",
+    IGNORE = "IGNORE",
+    PROMPT = "PROMPT",
+    FAIL_PROMPT = "FAIL_PROMPT",
+    FAIL_ERROR = "FAIL_ERROR",
 }

 /**
@@ -102,55 +42,36 @@ export class AutoDiscovery {
    // translate the meaning of the states in the spec, but also
    // support our own if needed.

-    static get ERROR_INVALID() {
-        return "Invalid homeserver discovery response";
-    }
+    public static readonly ERROR_INVALID = "Invalid homeserver discovery response";

-    static get ERROR_GENERIC_FAILURE() {
-        return "Failed to get autodiscovery configuration from server";
-    }
+    public static readonly ERROR_GENERIC_FAILURE = "Failed to get autodiscovery configuration from server";

-    static get ERROR_INVALID_HS_BASE_URL() {
-        return "Invalid base_url for m.homeserver";
-    }
+    public static readonly ERROR_INVALID_HS_BASE_URL = "Invalid base_url for m.homeserver";

-    static get ERROR_INVALID_HOMESERVER() {
-        return "Homeserver URL does not appear to be a valid Matrix homeserver";
-    }
+    public static readonly ERROR_INVALID_HOMESERVER = "Homeserver URL does not appear to be a valid Matrix homeserver";

-    static get ERROR_INVALID_IS_BASE_URL() {
-        return "Invalid base_url for m.identity_server";
-    }
+    public static readonly ERROR_INVALID_IS_BASE_URL = "Invalid base_url for m.identity_server";

-    static get ERROR_INVALID_IDENTITY_SERVER() {
-        return "Identity server URL does not appear to be a valid identity server";
-    }
+    // eslint-disable-next-line
+    public static readonly ERROR_INVALID_IDENTITY_SERVER = "Identity server URL does not appear to be a valid identity server";

-    static get ERROR_INVALID_IS() {
-        return "Invalid identity server discovery response";
-    }
+    public static readonly ERROR_INVALID_IS = "Invalid identity server discovery response";

-    static get ERROR_MISSING_WELLKNOWN() {
-        return "No .well-known JSON file found";
-    }
+    public static readonly ERROR_MISSING_WELLKNOWN = "No .well-known JSON file found";

-    static get ERROR_INVALID_JSON() {
-        return "Invalid JSON";
-    }
+    public static readonly ERROR_INVALID_JSON = "Invalid JSON";

-    static get ALL_ERRORS() {
-        return [
-            AutoDiscovery.ERROR_INVALID,
-            AutoDiscovery.ERROR_GENERIC_FAILURE,
-            AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
-            AutoDiscovery.ERROR_INVALID_HOMESERVER,
-            AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
-            AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
-            AutoDiscovery.ERROR_INVALID_IS,
-            AutoDiscovery.ERROR_MISSING_WELLKNOWN,
-            AutoDiscovery.ERROR_INVALID_JSON,
-        ];
-    }
+    public static readonly ALL_ERRORS = [
+        AutoDiscovery.ERROR_INVALID,
+        AutoDiscovery.ERROR_GENERIC_FAILURE,
+        AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
+        AutoDiscovery.ERROR_INVALID_HOMESERVER,
+        AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
+        AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
+        AutoDiscovery.ERROR_INVALID_IS,
+        AutoDiscovery.ERROR_MISSING_WELLKNOWN,
+        AutoDiscovery.ERROR_INVALID_JSON,
+    ];

    /**
     * The auto discovery failed. The client is expected to communicate
@@ -158,7 +79,7 @@ export class AutoDiscovery {
     * @return {string}
     * @constructor
     */
-    static get FAIL_ERROR() { return "FAIL_ERROR"; }
+    public static readonly FAIL_ERROR = AutoDiscoveryAction.FAIL_ERROR;

    /**
     * The auto discovery failed, however the client may still recover
@@ -169,7 +90,7 @@ export class AutoDiscovery {
     * @return {string}
     * @constructor
     */
-    static get FAIL_PROMPT() { return "FAIL_PROMPT"; }
+    public static readonly FAIL_PROMPT = AutoDiscoveryAction.FAIL_PROMPT;

    /**
     * The auto discovery didn't fail but did not find anything of
@@ -178,14 +99,14 @@ export class AutoDiscovery {
     * @return {string}
     * @constructor
     */
-    static get PROMPT() { return "PROMPT"; }
+    public static readonly PROMPT = AutoDiscoveryAction.PROMPT;

    /**
     * The auto discovery was successful.
     * @return {string}
     * @constructor
     */
-    static get SUCCESS() { return "SUCCESS"; }
+    public static readonly SUCCESS = AutoDiscoveryAction.SUCCESS;

    /**
     * Validates and verifies client configuration information for purposes
@@ -193,13 +114,13 @@ 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 {string} wellknown The configuration object itself, as returned
+     * @param {object} wellknown The configuration object itself, as returned
     * by the .well-known auto-discovery endpoint.
     * @return {Promise<DiscoveredClientConfig>} Resolves to the verified
     * configuration, which may include error states. Rejects on unexpected
     * failure, not when verification fails.
     */
-    static async fromDiscoveryConfig(wellknown) {
+    public static async fromDiscoveryConfig(wellknown: any): Promise<IClientWellKnown> {
        // 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
@@ -240,7 +161,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(
+        const hsUrl = this.sanitizeWellKnownUrl(
            wellknown["m.homeserver"]["base_url"],
        );
        if (!hsUrl) {
@@ -250,7 +171,7 @@ export class AutoDiscovery {
        }

        // Step 3: Make sure the homeserver URL points to a homeserver.
-        const hsVersions = await this._fetchWellKnownObject(
+        const hsVersions = await this.fetchWellKnownObject(
            `${hsUrl}/_matrix/client/versions`,
        );
        if (!hsVersions || !hsVersions.raw["versions"]) {
@@ -272,7 +193,7 @@ export class AutoDiscovery {
        };

        // Step 5: Try to pull out the identity server configuration
-        let isUrl = "";
+        let isUrl: string | boolean = "";
        if (wellknown["m.identity_server"]) {
            // We prepare a failing identity server response to save lines later
            // in this branch.
@@ -287,7 +208,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(
+            isUrl = this.sanitizeWellKnownUrl(
                wellknown["m.identity_server"]["base_url"],
            );
            if (!isUrl) {
@@ -299,10 +220,10 @@ export class AutoDiscovery {

            // Step 5b: Verify there is an identity server listening on the provided
            // URL.
-            const isResponse = await this._fetchWellKnownObject(
+            const isResponse = await this.fetchWellKnownObject(
                `${isUrl}/_matrix/identity/api/v1`,
            );
-            if (!isResponse || !isResponse.raw || isResponse.action !== "SUCCESS") {
+            if (!isResponse || !isResponse.raw || isResponse.action !== AutoDiscoveryAction.SUCCESS) {
                logger.error("Invalid /api/v1 response");
                failingClientConfig["m.identity_server"].error =
                    AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER;
@@ -317,7 +238,7 @@ export class AutoDiscovery {

        // Step 6: Now that the identity server is valid, or never existed,
        // populate the IS section.
-        if (isUrl && isUrl.length > 0) {
+        if (isUrl && isUrl.toString().length > 0) {
            clientConfig["m.identity_server"] = {
                state: AutoDiscovery.SUCCESS,
                error: null,
@@ -359,7 +280,7 @@ export class AutoDiscovery {
     * configuration, which may include error states. Rejects on unexpected
     * failure, not when discovery fails.
     */
-    static async findClientConfig(domain) {
+    public static async findClientConfig(domain: string): Promise<IClientWellKnown> {
        if (!domain || typeof(domain) !== "string" || domain.length === 0) {
            throw new Error("'domain' must be a string of non-zero length");
        }
@@ -395,13 +316,13 @@ 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(
+        const wellknown = await this.fetchWellKnownObject(
            `https://${domain}/.well-known/matrix/client`,
        );
-        if (!wellknown || wellknown.action !== "SUCCESS") {
+        if (!wellknown || wellknown.action !== AutoDiscoveryAction.SUCCESS) {
            logger.error("No response or error when parsing .well-known");
            if (wellknown.reason) logger.error(wellknown.reason);
-            if (wellknown.action === "IGNORE") {
+            if (wellknown.action === AutoDiscoveryAction.IGNORE) {
                clientConfig["m.homeserver"] = {
                    state: AutoDiscovery.PROMPT,
                    error: null,
@@ -427,12 +348,12 @@ export class AutoDiscovery {
     * @returns {Promise<object>} Resolves to the domain's client config. Can
     * be an empty object.
     */
-    static async getRawClientConfig(domain) {
+    public static async getRawClientConfig(domain: string): Promise<IClientWellKnown> {
        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(
+        const response = await this.fetchWellKnownObject(
            `https://${domain}/.well-known/matrix/client`,
        );
        if (!response) return {};
@@ -447,7 +368,7 @@ export class AutoDiscovery {
     * @return {string|boolean} The sanitized URL or a falsey value if the URL is invalid.
     * @private
     */
-    static _sanitizeWellKnownUrl(url) {
+    private static sanitizeWellKnownUrl(url: string): string | boolean {
        if (!url) return false;

        try {
@@ -495,8 +416,9 @@ export class AutoDiscovery {
     * @return {Promise<object>} Resolves to the returned state.
     * @private
     */
-    static async _fetchWellKnownObject(url) {
+    private static async fetchWellKnownObject(url: string): Promise<IWellKnownConfig> {
        return new Promise(function(resolve, reject) {
+            // eslint-disable-next-line
            const request = require("./matrix").getRequest();
            if (!request) throw new Error("No request library available");
            request(
@@ -505,10 +427,10 @@ export class AutoDiscovery {
                    if (err || response &&
                        (response.statusCode < 200 || response.statusCode >= 300)
                    ) {
-                        let action = "FAIL_PROMPT";
+                        let action = AutoDiscoveryAction.FAIL_PROMPT;
                        let reason = (err ? err.message : null) || "General failure";
                        if (response && response.statusCode === 404) {
-                            action = "IGNORE";
+                            action = AutoDiscoveryAction.IGNORE;
                            reason = AutoDiscovery.ERROR_MISSING_WELLKNOWN;
                        }
                        resolve({ raw: {}, action: action, reason: reason, error: err });
@@ -516,7 +438,7 @@ export class AutoDiscovery {
                    }

                    try {
-                        resolve({ raw: JSON.parse(body), action: "SUCCESS" });
+                        resolve({ raw: JSON.parse(body), action: AutoDiscoveryAction.SUCCESS });
                    } catch (e) {
                        let reason = AutoDiscovery.ERROR_INVALID;
                        if (e.name === "SyntaxError") {
@@ -524,7 +446,7 @@ export class AutoDiscovery {
                        }
                        resolve({
                            raw: {},
-                            action: "FAIL_PROMPT",
+                            action: AutoDiscoveryAction.FAIL_PROMPT,
                            reason: reason,
                            error: e,
                        });
@@ -31,9 +31,10 @@ import { sleep } from './utils';
 import { Group } from "./models/group";
 import { Direction, EventTimeline } from "./models/event-timeline";
 import { IActionsObject, PushProcessor } from "./pushprocessor";
-import { AutoDiscovery } from "./autodiscovery";
+import { AutoDiscovery, AutoDiscoveryAction } from "./autodiscovery";
 import * as olmlib from "./crypto/olmlib";
 import { decodeBase64, encodeBase64 } from "./crypto/olmlib";
+import { IExportedDevice as IOlmDevice } from "./crypto/OlmDevice";
 import { ReEmitter } from './ReEmitter';
 import { IRoomEncryption, RoomList } from './crypto/RoomList';
 import { logger } from './logger';
@@ -74,7 +75,6 @@ import {
    IKeyBackupPrepareOpts,
    IKeyBackupRestoreOpts,
    IKeyBackupRestoreResult,
-    IKeyBackupSession,
 } from "./crypto/keybackup";
 import { IIdentityServerProvider } from "./@types/IIdentityServerProvider";
 import type Request from "request";
@@ -92,7 +92,7 @@ import {
 import { SyncState } from "./sync.api";
 import { EventTimelineSet } from "./models/event-timeline-set";
 import { VerificationRequest } from "./crypto/verification/request/VerificationRequest";
-import { Base as Verification } from "./crypto/verification/Base";
+import { VerificationBase as Verification } from "./crypto/verification/Base";
 import * as ContentHelpers from "./content-helpers";
 import { CrossSigningInfo, DeviceTrustLevel, ICacheCallbacks, UserTrustLevel } from "./crypto/CrossSigning";
 import { Room } from "./models/room";
@@ -144,6 +144,7 @@ import { IHierarchyRoom, ISpaceSummaryEvent, ISpaceSummaryRoom } from "./@types/
 import { IPusher, IPusherRequest, IPushRules, PushRuleAction, PushRuleKind, RuleId } from "./@types/PushRules";
 import { IThreepid } from "./@types/threepids";
 import { CryptoStore } from "./crypto/store/base";
+import { MediaHandler } from "./webrtc/mediaHandler";

 export type Store = IStore;
 export type SessionStore = WebStorageSessionStore;
@@ -156,12 +157,6 @@ export const CRYPTO_ENABLED: boolean = isCryptoAvailable();
 const CAPABILITIES_CACHE_MS = 21600000; // 6 hours - an arbitrary value
 const TURN_CHECK_INTERVAL = 10 * 60 * 1000; // poll for turn credentials every 10 minutes

-interface IOlmDevice {
-    pickledAccount: string;
-    sessions: Array<Record<string, IKeyBackupSession>>;
-    pickleKey: string;
-}
-
 interface IExportedDevice {
    olmDevice: IOlmDevice;
    userId: string;
@@ -481,14 +476,19 @@ interface IServerVersions {
    unstable_features: Record<string, boolean>;
 }

-interface IClientWellKnown {
+export interface IClientWellKnown {
    [key: string]: any;
-    "m.homeserver": {
-        base_url: string;
-    };
-    "m.identity_server"?: {
-        base_url: string;
-    };
+    "m.homeserver"?: IWellKnownConfig;
+    "m.identity_server"?: IWellKnownConfig;
+}
+
+export interface IWellKnownConfig {
+    raw?: any; // todo typings
+    action?: AutoDiscoveryAction;
+    reason?: string;
+    error?: Error | string;
+    // eslint-disable-next-line
+    base_url?: string | null;
 }

 interface IKeyBackupPath {
@@ -531,7 +531,7 @@ export interface IRequestTokenResponse {
    submit_url?: string;
 }

-interface IRequestMsisdnTokenResponse extends IRequestTokenResponse {
+export interface IRequestMsisdnTokenResponse extends IRequestTokenResponse {
    msisdn: string;
    success: boolean;
    intl_fmt: string;
@@ -568,6 +568,10 @@ interface IRoomInitialSyncResponse {
    presence: Partial<IEvent>; // legacy and undocumented, api is deprecated so this won't get attention
 }

+interface IJoinedRoomsResponse {
+    joined_rooms: string[];
+}
+
 interface IJoinedMembersResponse {
    joined: {
        [userId: string]: {
@@ -678,7 +682,7 @@ export class MatrixClient extends EventEmitter {
    public static readonly RESTORE_BACKUP_ERROR_BAD_KEY = 'RESTORE_BACKUP_ERROR_BAD_KEY';

    public reEmitter = new ReEmitter(this);
-    public olmVersion: string = null; // populated after initCrypto
+    public olmVersion: [number, number, number] = null; // populated after initCrypto
    public usingExternalCrypto = false;
    public store: Store;
    public deviceId?: string;
@@ -739,6 +743,7 @@ export class MatrixClient extends EventEmitter {
    protected checkTurnServersIntervalID: number;
    protected exportedOlmDeviceToImport: IOlmDevice;
    protected txnCtr = 0;
+    protected mediaHandler = new MediaHandler();

    constructor(opts: IMatrixClientCreateOpts) {
        super();
@@ -1246,6 +1251,13 @@ export class MatrixClient extends EventEmitter {
        return this.canSupportVoip;
    }

+    /**
+     * @returns {MediaHandler}
+     */
+    public getMediaHandler(): MediaHandler {
+        return this.mediaHandler;
+    }
+
    /**
     * Set whether VoIP calls are forced to use only TURN
     * candidates. This is the same as the forceTURN option
@@ -2033,7 +2045,7 @@ export class MatrixClient extends EventEmitter {
     *     recovery key which should be disposed of after displaying to the user,
     *     and raw private key to avoid round tripping if needed.
     */
-    public createRecoveryKeyFromPassphrase(password: string): Promise<IRecoveryKey> {
+    public createRecoveryKeyFromPassphrase(password?: string): Promise<IRecoveryKey> {
        if (!this.crypto) {
            throw new Error("End-to-end encryption disabled");
        }
@@ -2362,7 +2374,7 @@ export class MatrixClient extends EventEmitter {
     * @return {Promise} a promise which resolves when the keys
     *    have been imported
     */
-    public importRoomKeys(keys: IMegolmSessionData[], opts: IImportRoomKeysOpts): Promise<void> {
+    public importRoomKeys(keys: IMegolmSessionData[], opts?: IImportRoomKeysOpts): Promise<void> {
        if (!this.crypto) {
            throw new Error("End-to-end encryption disabled");
        }
@@ -2476,7 +2488,7 @@ export class MatrixClient extends EventEmitter {
     */
    // TODO: Verify types
    public async prepareKeyBackupVersion(
-        password: string,
+        password?: string,
        opts: IKeyBackupPrepareOpts = { secureSecretStorage: false },
    ): Promise<Pick<IPreparedKeyBackupVersion, "algorithm" | "auth_data" | "recovery_key">> {
        if (!this.crypto) {
@@ -4031,10 +4043,8 @@ export class MatrixClient extends EventEmitter {
        // Work backwards first, looking at create events.
        let createEvent = currentRoom.currentState.getStateEvents(EventType.RoomCreate, "");
        while (createEvent) {
-            logger.log(`Looking at ${createEvent.getId()}`);
            const predecessor = createEvent.getContent()['predecessor'];
            if (predecessor && predecessor['room_id']) {
-                logger.log(`Looking at predecessor ${predecessor['room_id']}`);
                const refRoom = this.getRoom(predecessor['room_id']);
                if (!refRoom) break; // end of the chain

@@ -4280,7 +4290,16 @@ export class MatrixClient extends EventEmitter {
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
    public kick(roomId: string, userId: string, reason?: string, callback?: Callback): Promise<{}> {
-        return this.setMembershipState(roomId, userId, "leave", reason, callback);
+        const path = utils.encodeUri("/rooms/$roomId/kick", {
+            $roomId: roomId,
+        });
+        const data = {
+            user_id: userId,
+            reason: reason,
+        };
+        return this.http.authedRequest(
+            callback, "POST", path, undefined, data,
+        );
    }

    /**
@@ -5014,7 +5033,7 @@ export class MatrixClient extends EventEmitter {
        email: string,
        clientSecret: string,
        sendAttempt: number,
-        nextLink: string,
+        nextLink?: string,
    ): Promise<IRequestTokenResponse> {
        return this.requestTokenFromEndpoint(
            "/account/3pid/email/requestToken",
@@ -5046,7 +5065,7 @@ export class MatrixClient extends EventEmitter {
        phoneNumber: string,
        clientSecret: string,
        sendAttempt: number,
-        nextLink: string,
+        nextLink?: string,
    ): Promise<IRequestMsisdnTokenResponse> {
        return this.requestTokenFromEndpoint(
            "/account/3pid/msisdn/requestToken",
@@ -6113,17 +6132,17 @@ export class MatrixClient extends EventEmitter {
    public register(
        username: string,
        password: string,
-        sessionId: string,
-        auth: any,
-        bindThreepids: any,
-        guestAccessToken: string,
-        inhibitLogin: boolean,
+        sessionId: string | null,
+        auth: { session?: string, type: string },
+        bindThreepids?: boolean | null | { email?: boolean, msisdn?: boolean },
+        guestAccessToken?: string,
+        inhibitLogin?: boolean,
        callback?: Callback,
    ): Promise<any> { // TODO: Types (many)
        // backwards compat
        if (bindThreepids === true) {
            bindThreepids = { email: true };
-        } else if (bindThreepids === null || bindThreepids === undefined) {
+        } else if (bindThreepids === null || bindThreepids === undefined || bindThreepids === false) {
            bindThreepids = {};
        }
        if (typeof inhibitLogin === 'function') {
@@ -6657,7 +6676,7 @@ export class MatrixClient extends EventEmitter {
     * @return {Promise} Resolves: A list of the user's current rooms
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
-    public getJoinedRooms(): Promise<string[]> {
+    public getJoinedRooms(): Promise<IJoinedRoomsResponse> {
        const path = utils.encodeUri("/joined_rooms", {});
        return this.http.authedRequest(undefined, "GET", path);
    }
@@ -7457,7 +7476,7 @@ export class MatrixClient extends EventEmitter {
        return this.http.authedRequest(undefined, "GET", path, qps, undefined);
    }

-    public uploadDeviceSigningKeys(auth: any, keys: CrossSigningKeys): Promise<{}> { // TODO: types
+    public uploadDeviceSigningKeys(auth: any, keys?: CrossSigningKeys): Promise<{}> { // TODO: types
        const data = Object.assign({}, keys);
        if (auth) Object.assign(data, { auth });
        return this.http.authedRequest(
@@ -8495,6 +8514,13 @@ export class MatrixClient extends EventEmitter {
            publicise: isPublic,
        });
    }
+
+    /**
+     * @experimental
+     */
+    public supportsExperimentalThreads(): boolean {
+        return this.clientOpts?.experimentalThreadSupport || false;
+    }
 }

 /**
@@ -713,7 +713,7 @@ export function createCryptoStoreCacheCallbacks(store: CryptoStore, olmDevice: O
            });

            if (key && key.ciphertext) {
-                const pickleKey = Buffer.from(olmDevice._pickleKey);
+                const pickleKey = Buffer.from(olmDevice.pickleKey);
                const decrypted = await decryptAES(key, pickleKey, type);
                return decodeBase64(decrypted);
            } else {
@@ -726,7 +726,7 @@ export function createCryptoStoreCacheCallbacks(store: CryptoStore, olmDevice: O
                    `storeCrossSigningKeyCache expects Uint8Array, got ${key}`,
                );
            }
-            const pickleKey = Buffer.from(olmDevice._pickleKey);
+            const pickleKey = Buffer.from(olmDevice.pickleKey);
            const encryptedKey = await encryptAES(encodeBase64(key), pickleKey, type);
            return store.doTxn(
                'readwrite',
@@ -739,6 +739,8 @@ export function createCryptoStoreCacheCallbacks(store: CryptoStore, olmDevice: O
    };
 }

+export type KeysDuringVerification = [[string, PkSigning], [string, PkSigning], [string, PkSigning], void];
+
 /**
 * Request cross-signing keys from another device during verification.
 *
@@ -746,15 +748,19 @@ export function createCryptoStoreCacheCallbacks(store: CryptoStore, olmDevice: O
 * @param {string} userId The user ID being verified
 * @param {string} deviceId The device ID being verified
 */
-export async function requestKeysDuringVerification(baseApis: MatrixClient, userId: string, deviceId: string) {
+export function requestKeysDuringVerification(
+    baseApis: MatrixClient,
+    userId: string,
+    deviceId: string,
+): Promise<KeysDuringVerification | void> {
    // If this is a self-verification, ask the other party for keys
    if (baseApis.getUserId() !== userId) {
        return;
    }
    logger.log("Cross-signing: Self-verification done; requesting keys");
    // This happens asynchronously, and we're not concerned about waiting for
-    // it.  We return here in order to test.
-    return new Promise((resolve, reject) => {
+    // it. We return here in order to test.
+    return new Promise<KeysDuringVerification | void>((resolve, reject) => {
        const client = baseApis;
        const original = client.crypto.crossSigningInfo;

@@ -781,7 +787,7 @@ export async function requestKeysDuringVerification(baseApis: MatrixClient, user
        // https://github.com/vector-im/element-web/issues/12604
        // then change here to reject on the timeout
        // Requests can be ignored, so don't wait around forever
-        const timeout = new Promise((resolve, reject) => {
+        const timeout = new Promise<void>((resolve) => {
            setTimeout(
                resolve,
                KEY_REQUEST_TIMEOUT_MS,
@@ -801,7 +807,7 @@ export async function requestKeysDuringVerification(baseApis: MatrixClient, user
                logger.info("Got key backup key, decoding...");
                const decodedKey = decodeBase64(base64Key);
                logger.info("Decoded backup key, storing...");
-                client.crypto.storeSessionBackupPrivateKey(
+                await client.crypto.storeSessionBackupPrivateKey(
                    Uint8Array.from(decodedKey),
                );
                logger.info("Backup key stored. Starting backup restore...");
@@ -814,13 +820,13 @@ export async function requestKeysDuringVerification(baseApis: MatrixClient, user
        })();

        // We call getCrossSigningKey() for its side-effects
-        return Promise.race([
+        return Promise.race<KeysDuringVerification | void>([
            Promise.all([
                crossSigning.getCrossSigningKey("master"),
                crossSigning.getCrossSigningKey("self_signing"),
                crossSigning.getCrossSigningKey("user_signing"),
                backupKeyPromise,
-            ]),
+            ]) as Promise<KeysDuringVerification>,
            timeout,
        ]).then(resolve, reject);
    }).catch((e) => {
@@ -26,9 +26,10 @@ const subtleCrypto = (typeof window !== "undefined" && window.crypto) ?
 const zeroSalt = new Uint8Array(8);

 export interface IEncryptedPayload {
-    iv: string;
-    ciphertext: string;
-    mac: string;
+    [key: string]: any; // extensible
+    iv?: string;
+    ciphertext?: string;
+    mac?: string;
 }

 /**
@@ -67,7 +67,7 @@ export interface IOlmDevice<T = DeviceInfo> {
 }

 /* eslint-disable camelcase */
-interface IOutboundGroupSessionKey {
+export interface IOutboundGroupSessionKey {
    chain_index: number;
    key: string;
 }
@@ -341,12 +341,15 @@ class MegolmEncryption extends EncryptionAlgorithm {
            await Promise.all([
                (async () => {
                    // share keys with devices that we already have a session for
-                    logger.debug(`Sharing keys with existing Olm sessions in ${this.roomId}`);
+                    logger.debug(`Sharing keys with existing Olm sessions in ${this.roomId}`, olmSessions);
                    await this.shareKeyWithOlmSessions(session, key, payload, olmSessions);
                    logger.debug(`Shared keys with existing Olm sessions in ${this.roomId}`);
                })(),
                (async () => {
-                    logger.debug(`Sharing keys (start phase 1) with new Olm sessions in ${this.roomId}`);
+                    logger.debug(
+                        `Sharing keys (start phase 1) with new Olm sessions in ${this.roomId}`,
+                        devicesWithoutSession,
+                    );
                    const errorDevices = [];

                    // meanwhile, establish olm sessions for devices that we don't
@@ -403,8 +406,11 @@ class MegolmEncryption extends EncryptionAlgorithm {
                    logger.debug(`Shared keys (all phases done) with new Olm sessions in ${this.roomId}`);
                })(),
                (async () => {
-                    logger.debug(`Notifying blocked devices in ${this.roomId}`);
-                    // also, notify blocked devices that they're 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}`);
                    const blockedMap: Record<string, Record<string, { device: IBlockedDevice }>> = {};
                    let blockedCount = 0;
                    for (const [userId, userBlockedDevices] of Object.entries(blocked)) {
@@ -421,7 +427,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
                    }

                    await this.notifyBlockedDevices(session, blockedMap);
-                    logger.debug(`Notified ${blockedCount} blocked devices in ${this.roomId}`);
+                    logger.debug(`Notified ${blockedCount} newly blocked devices in ${this.roomId}`, blockedMap);
                })(),
            ]);
        };
@@ -697,7 +703,7 @@ class MegolmEncryption extends EncryptionAlgorithm {

        await this.baseApis.sendToDevice("org.matrix.room_key.withheld", contentMap);

-        // store that we successfully uploaded the keys of the current slice
+        // record the fact that we notified these blocked devices
        for (const userId of Object.keys(contentMap)) {
            for (const deviceId of Object.keys(contentMap[userId])) {
                session.markNotifiedBlockedDevice(userId, deviceId);
@@ -846,9 +852,9 @@ class MegolmEncryption extends EncryptionAlgorithm {

        this.getDevicesWithoutSessions(devicemap, devicesByUser, errorDevices);

-        logger.debug(`Sharing keys with Olm sessions in ${this.roomId}`);
+        logger.debug(`Sharing keys with newly created Olm sessions in ${this.roomId}`);
        await this.shareKeyWithOlmSessions(session, key, payload, devicemap);
-        logger.debug(`Shared keys with Olm sessions in ${this.roomId}`);
+        logger.debug(`Shared keys with newly created Olm sessions in ${this.roomId}`);
    }

    private async shareKeyWithOlmSessions(
@@ -864,7 +870,8 @@ class MegolmEncryption extends EncryptionAlgorithm {
                `megolm keys for ${session.sessionId} ` +
                `in ${this.roomId} (slice ${i + 1}/${userDeviceMaps.length})`;
            try {
-                logger.debug(`Sharing ${taskDetail}`);
+                logger.debug(`Sharing ${taskDetail}`,
+                    userDeviceMaps[i].map((d) => `${d.userId}/${d.deviceInfo.deviceId}`));
                await this.encryptAndSendKeysToDevices(
                    session, key.chain_index, userDeviceMaps[i], payload,
                );
@@ -906,16 +913,16 @@ class MegolmEncryption extends EncryptionAlgorithm {
            );
        }

-        const filteredFailedDevices =
+        const unnotifiedFailedDevices =
            await this.olmDevice.filterOutNotifiedErrorDevices(
                failedDevices,
            );
        logger.debug(
-            `Filtered down to ${filteredFailedDevices.length} error devices ` +
-            `in ${this.roomId}`,
+            `Need to notify ${unnotifiedFailedDevices.length} failed devices ` +
+            `which haven't been notified before in ${this.roomId}`,
        );
        const blockedMap: Record<string, Record<string, { device: IBlockedDevice }>> = {};
-        for (const { userId, deviceInfo } of filteredFailedDevices) {
+        for (const { userId, deviceInfo } of unnotifiedFailedDevices) {
            blockedMap[userId] = blockedMap[userId] || {};
            // we use a similar format to what
            // olmlib.ensureOlmSessionsForDevices returns, so that
@@ -932,7 +939,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
        // send the notifications
        await this.notifyBlockedDevices(session, blockedMap);
        logger.debug(
-            `Notified ${filteredFailedDevices.length} devices we failed to ` +
+            `Notified ${unnotifiedFailedDevices.length} devices we failed to ` +
            `create Olm sessions in ${this.roomId}`,
        );
    }
@@ -1411,7 +1418,7 @@ class MegolmDecryption extends DecryptionAlgorithm {
     *
     * @param {module:models/event.MatrixEvent} event key event
     */
-    public onRoomKeyEvent(event: MatrixEvent): void {
+    public onRoomKeyEvent(event: MatrixEvent): Promise<void> {
        const content = event.getContent();
        const sessionId = content.session_id;
        let senderKey = event.getSenderKey();
@@ -36,7 +36,7 @@ import { IEventDecryptionResult } from "../index";
 const DeviceVerification = DeviceInfo.DeviceVerification;

 interface IMessage {
-    type: number | string;
+    type: number;
    body: string;
 }

@@ -269,11 +269,11 @@ class OlmDecryption extends DecryptionAlgorithm {
            // not a prekey message: we can safely just try & decrypt it
            return this.reallyDecryptMessage(theirDeviceIdentityKey, message);
        } else {
-            const myPromise = this.olmDevice._olmPrekeyPromise.then(() => {
+            const myPromise = this.olmDevice.olmPrekeyPromise.then(() => {
                return this.reallyDecryptMessage(theirDeviceIdentityKey, message);
            });
            // we want the error, but don't propagate it to the next decryption
-            this.olmDevice._olmPrekeyPromise = myPromise.catch(() => {});
+            this.olmDevice.olmPrekeyPromise = myPromise.catch(() => {});
            return await myPromise;
        }
    }
@@ -58,7 +58,7 @@ export interface IEncryptedEventInfo {
 }

 export interface IRecoveryKey {
-    keyInfo: {
+    keyInfo?: {
        pubkey: string;
        passphrase?: {
            algorithm: string;
@@ -67,7 +67,7 @@ export interface IRecoveryKey {
        };
    };
    privateKey: Uint8Array;
-    encodedPrivateKey: string;
+    encodedPrivateKey?: string;
 }

 export interface ICreateSecretStorageOpts {
@@ -142,7 +142,7 @@ export interface IImportOpts {
 }

 export interface IImportRoomKeysOpts {
-    progressCallback: (stage: IImportOpts) => void;
+    progressCallback?: (stage: IImportOpts) => void;
    untrusted?: boolean;
    source?: string; // TODO: Enum
 }
@@ -49,6 +49,8 @@ type SigInfo = {
 export type TrustInfo = {
    usable: boolean; // is the backup trusted, true iff there is a sig that is valid & from a trusted device
    sigs: SigInfo[];
+    // eslint-disable-next-line camelcase
+    trusted_locally?: boolean;
 };

 export interface IKeyBackupCheck {
@@ -20,6 +20,7 @@ import { decryptAES, encryptAES } from './aes';
 import anotherjson from "another-json";
 import { logger } from '../logger';
 import { ISecretStorageKeyInfo } from "./api";
+import { Crypto } from "./index";

 // FIXME: these types should eventually go in a different file
 type Signatures = Record<string, Record<string, string>>;
@@ -60,7 +61,7 @@ export class DehydrationManager {
    private key: Uint8Array;
    private keyInfo: {[props: string]: any};
    private deviceDisplayName: string;
-    constructor(private crypto) {
+    constructor(private readonly crypto: Crypto) {
        this.getDehydrationKeyFromCache();
    }
    async getDehydrationKeyFromCache(): Promise<void> {
@@ -73,7 +74,7 @@ export class DehydrationManager {
                    async (result) => {
                        if (result) {
                            const { key, keyInfo, deviceDisplayName, time } = result;
-                            const pickleKey = Buffer.from(this.crypto.olmDevice._pickleKey);
+                            const pickleKey = Buffer.from(this.crypto.olmDevice.pickleKey);
                            const decrypted = await decryptAES(key, pickleKey, DEHYDRATION_ALGORITHM);
                            this.key = decodeBase64(decrypted);
                            this.keyInfo = keyInfo;
@@ -158,7 +159,7 @@ export class DehydrationManager {
            this.timeoutId = undefined;
        }
        try {
-            const pickleKey = Buffer.from(this.crypto.olmDevice._pickleKey);
+            const pickleKey = Buffer.from(this.crypto.olmDevice.pickleKey);

            // update the crypto store with the timestamp
            const key = await encryptAES(encodeBase64(this.key), pickleKey, DEHYDRATION_ALGORITHM);
@@ -68,7 +68,7 @@ export class DeviceInfo {
     *
     * @return {module:crypto~DeviceInfo} new DeviceInfo
     */
-    public static fromStorage(obj: IDevice, deviceId: string): DeviceInfo {
+    public static fromStorage(obj: Partial<IDevice>, deviceId: string): DeviceInfo {
        const res = new DeviceInfo(deviceId);
        for (const prop in obj) {
            if (obj.hasOwnProperty(prop)) {
@@ -26,7 +26,7 @@ import { EventEmitter } from 'events';

 import { ReEmitter } from '../ReEmitter';
 import { logger } from '../logger';
-import { OlmDevice } from "./OlmDevice";
+import { IExportedDevice, OlmDevice } from "./OlmDevice";
 import * as olmlib from "./olmlib";
 import { DeviceInfoMap, DeviceList } from "./DeviceList";
 import { DeviceInfo, IDevice } from "./deviceinfo";
@@ -40,7 +40,7 @@ import {
    ISecretRequest,
    SecretStorageKeyObject,
 } from './SecretStorage';
-import { IAddSecretStorageKeyOpts, ISecretStorageKeyInfo } from "./api";
+import { IAddSecretStorageKeyOpts, IImportRoomKeysOpts, ISecretStorageKeyInfo } from "./api";
 import { OutgoingRoomKeyRequestManager } from './OutgoingRoomKeyRequestManager';
 import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
 import { ReciprocateQRCode, SCAN_QR_CODE_METHOD, SHOW_QR_CODE_METHOD } from './verification/QRCode';
@@ -58,7 +58,7 @@ import { BackupManager } from "./backup";
 import { IStore } from "../store";
 import { Room } from "../models/room";
 import { RoomMember } from "../models/room-member";
-import { MatrixEvent } from "../models/event";
+import { MatrixEvent, EventStatus } from "../models/event";
 import { MatrixClient, IKeysUploadResponse, SessionStore, ISignedKey } from "../client";
 import type { EncryptionAlgorithm, DecryptionAlgorithm } from "./algorithms/base";
 import type { IRoomEncryption, RoomList } from "./RoomList";
@@ -66,6 +66,7 @@ import { IRecoveryKey, IEncryptedEventInfo } from "./api";
 import { IKeyBackupInfo } from "./keybackup";
 import { ISyncStateData } from "../sync";
 import { CryptoStore } from "./store/base";
+import { IVerificationChannel } from "./verification/request/Channel";

 const DeviceVerification = DeviceInfo.DeviceVerification;

@@ -84,12 +85,12 @@ const defaultVerificationMethods = {
 * verification method names
 */
 // legacy export identifier
-export enum verificationMethods {
-    RECIPROCATE_QR_CODE = ReciprocateQRCode.NAME,
-    SAS = SASVerification.NAME,
-}
+export const verificationMethods = {
+    RECIPROCATE_QR_CODE: ReciprocateQRCode.NAME,
+    SAS: SASVerification.NAME,
+};

-export type VerificationMethod = verificationMethods;
+export type VerificationMethod = keyof typeof verificationMethods | string;

 export function isCryptoAvailable(): boolean {
    return Boolean(global.Olm);
@@ -98,7 +99,7 @@ export function isCryptoAvailable(): boolean {
 const MIN_FORCE_SESSION_INTERVAL_MS = 60 * 60 * 1000;

 interface IInitOpts {
-    exportedOlmDevice?: any; // TODO types
+    exportedOlmDevice?: IExportedDevice;
    pickleKey?: string;
 }

@@ -130,13 +131,14 @@ export interface IRoomKeyRequestBody extends IRoomKey {
 }

 export interface IMegolmSessionData {
+    [key: string]: any; // extensible
    sender_key: string;
    forwarding_curve25519_key_chain: string[];
    sender_claimed_keys: Record<string, string>;
    room_id: string;
    session_id: string;
    session_key: string;
-    algorithm: string;
+    algorithm?: string;
    untrusted?: boolean;
 }
 /* eslint-enable camelcase */
@@ -192,7 +194,7 @@ export class Crypto extends EventEmitter {
    /**
     * @return {string} The version of Olm.
     */
-    static getOlmVersion(): string {
+    static getOlmVersion(): [number, number, number] {
        return OlmDevice.getOlmVersion();
    }

@@ -205,7 +207,7 @@ export class Crypto extends EventEmitter {

    private readonly reEmitter: ReEmitter;
    private readonly verificationMethods: any; // TODO types
-    private readonly supportedAlgorithms: string[];
+    public readonly supportedAlgorithms: string[];
    private readonly outgoingRoomKeyRequestManager: OutgoingRoomKeyRequestManager;
    private readonly toDeviceVerificationRequests: ToDeviceRequests;
    public readonly inRoomVerificationRequests: InRoomRequests;
@@ -291,7 +293,7 @@ export class Crypto extends EventEmitter {
    constructor(
        public readonly baseApis: MatrixClient,
        public readonly sessionStore: SessionStore,
-        private readonly userId: string,
+        public readonly userId: string,
        private readonly deviceId: string,
        private readonly clientStore: IStore,
        public readonly cryptoStore: CryptoStore,
@@ -504,7 +506,7 @@ export class Crypto extends EventEmitter {
     *     recovery key which should be disposed of after displaying to the user,
     *     and raw private key to avoid round tripping if needed.
     */
-    public async createRecoveryKeyFromPassphrase(password: string): Promise<IRecoveryKey> {
+    public async createRecoveryKeyFromPassphrase(password?: string): Promise<IRecoveryKey> {
        const decryption = new global.Olm.PkDecryption();
        try {
            const keyInfo: Partial<IRecoveryKey["keyInfo"]> = {};
@@ -1097,7 +1099,7 @@ export class Crypto extends EventEmitter {
            await this.storeSessionBackupPrivateKey(key);
        }
        if (key && key.ciphertext) {
-            const pickleKey = Buffer.from(this.olmDevice._pickleKey);
+            const pickleKey = Buffer.from(this.olmDevice.pickleKey);
            const decrypted = await decryptAES(key, pickleKey, "m.megolm_backup.v1");
            key = olmlib.decodeBase64(decrypted);
        }
@@ -1113,7 +1115,7 @@ export class Crypto extends EventEmitter {
        if (!(key instanceof Uint8Array)) {
            throw new Error(`storeSessionBackupPrivateKey expects Uint8Array, got ${key}`);
        }
-        const pickleKey = Buffer.from(this.olmDevice._pickleKey);
+        const pickleKey = Buffer.from(this.olmDevice.pickleKey);
        const encryptedKey = await encryptAES(olmlib.encodeBase64(key), pickleKey, "m.megolm_backup.v1");
        return this.cryptoStore.doTxn(
            'readwrite',
@@ -1912,7 +1914,7 @@ export class Crypto extends EventEmitter {

        const fallbackJson: Record<string, IOneTimeKey> = {};
        if (this.getNeedsNewFallback()) {
-            const fallbackKeys = await this.olmDevice.getFallbackKey() as Record<string, Record<string, string>>;
+            const fallbackKeys = await this.olmDevice.getFallbackKey();
            for (const [keyId, key] of Object.entries(fallbackKeys.curve25519)) {
                const k = { key, fallback: true };
                fallbackJson["signed_curve25519:" + keyId] = k;
@@ -2176,11 +2178,11 @@ export class Crypto extends EventEmitter {
        return this.inRoomVerificationRequests.findRequestInProgress(roomId);
    }

-    public getVerificationRequestsToDeviceInProgress(userId: string): VerificationRequest {
+    public getVerificationRequestsToDeviceInProgress(userId: string): VerificationRequest[] {
        return this.toDeviceVerificationRequests.getRequestsInProgress(userId);
    }

-    public requestVerificationDM(userId: string, roomId: string): VerificationRequest {
+    public requestVerificationDM(userId: string, roomId: string): Promise<VerificationRequest> {
        const existingRequest = this.inRoomVerificationRequests.findRequestInProgress(roomId);
        if (existingRequest) {
            return Promise.resolve(existingRequest);
@@ -2193,7 +2195,7 @@ export class Crypto extends EventEmitter {
        );
    }

-    public requestVerification(userId: string, devices: string[]): VerificationRequest {
+    public requestVerification(userId: string, devices: string[]): Promise<VerificationRequest> {
        if (!devices) {
            devices = Object.keys(this.deviceList.getRawStoredDevicesForUser(userId));
        }
@@ -2211,9 +2213,9 @@ export class Crypto extends EventEmitter {

    private async requestVerificationWithChannel(
        userId: string,
-        channel: any, // TODO types
+        channel: IVerificationChannel,
        requestsMap: any, // TODO types
-    ): VerificationRequest {
+    ): Promise<VerificationRequest> {
        let request = new VerificationRequest(channel, this.verificationMethods, this.baseApis);
        // if transaction id is already known, add request
        if (channel.transactionId) {
@@ -2259,14 +2261,11 @@ export class Crypto extends EventEmitter {
        userId: string,
        deviceId: string,
        method: VerificationMethod,
-    ): VerificationRequest {
+    ): Promise<VerificationRequest> {
        const transactionId = ToDeviceChannel.makeTransactionId();
-        const channel = new ToDeviceChannel(
-            this.baseApis, userId, [deviceId], transactionId, deviceId);
-        const request = new VerificationRequest(
-            channel, this.verificationMethods, this.baseApis);
-        this.toDeviceVerificationRequests.setRequestBySenderAndTxnId(
-            userId, transactionId, request);
+        const channel = new ToDeviceChannel(this.baseApis, userId, [deviceId], transactionId, deviceId);
+        const request = new VerificationRequest(channel, this.verificationMethods, this.baseApis);
+        this.toDeviceVerificationRequests.setRequestBySenderAndTxnId(userId, transactionId, request);
        const verifier = request.beginKeyVerification(method, { userId, deviceId });
        // either reject by an error from verify() while sending .start
        // or resolve when the request receives the
@@ -2659,7 +2658,7 @@ export class Crypto extends EventEmitter {
     * @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
     */
-    public importRoomKeys(keys: IMegolmSessionData[], opts: any = {}): Promise<any> { // TODO types
+    public importRoomKeys(keys: IMegolmSessionData[], opts: IImportRoomKeysOpts = {}): Promise<any> { // TODO types
        let successes = 0;
        let failures = 0;
        const total = keys.length;
@@ -3202,6 +3201,29 @@ export class Crypto extends EventEmitter {
        createRequest: any, // TODO types
        isLiveEvent = true,
    ): Promise<void> {
+        // Wait for event to get its final ID with pendingEventOrdering: "chronological", since DM channels depend on it.
+        if (event.isSending() && event.status != EventStatus.SENT) {
+            let eventIdListener;
+            let statusListener;
+            try {
+                await new Promise((resolve, reject) => {
+                    eventIdListener = resolve;
+                    statusListener = () => {
+                        if (event.status == EventStatus.CANCELLED) {
+                            reject(new Error("Event status set to CANCELLED."));
+                        }
+                    };
+                    event.once("Event.localEventIdReplaced", eventIdListener);
+                    event.on("Event.status", statusListener);
+                });
+            } catch (err) {
+                logger.error("error while waiting for the verification event to be sent: " + err.message);
+                return;
+            } finally {
+                event.removeListener("Event.localEventIdReplaced", eventIdListener);
+                event.removeListener("Event.status", statusListener);
+            }
+        }
        let request = requestsMap.getRequest(event);
        let isNewRequest = false;
        if (!request) {
@@ -24,7 +24,7 @@ import anotherjson from "another-json";
 import type { PkSigning } from "@matrix-org/olm";
 import { Logger } from "loglevel";

-import OlmDevice from "./OlmDevice";
+import { OlmDevice } from "./OlmDevice";
 import { DeviceInfo } from "./deviceinfo";
 import { logger } from '../logger';
 import * as utils from "../utils";
@@ -252,13 +252,13 @@ export async function ensureOlmSessionsForDevices(
                continue;
            }

-            if (!olmDevice._sessionsInProgress[key]) {
+            if (!olmDevice.sessionsInProgress[key]) {
                // 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) => {
-                        delete olmDevice._sessionsInProgress[key];
+                        delete olmDevice.sessionsInProgress[key];
                        resolve(v);
                    };
                });
@@ -291,9 +291,7 @@ export async function ensureOlmSessionsForDevices(
            }

            const forWhom = `for ${key} (${userId}:${deviceId})`;
-            const sessionId = await olmDevice.getSessionIdForDevice(
-                key, resolveSession[key], log,
-            );
+            const sessionId = await olmDevice.getSessionIdForDevice(key, !!resolveSession[key], log);
            if (sessionId !== null && resolveSession[key]) {
                // we found a session, but we had marked the session as
                // in-progress, so resolve it now, which will unmark it and
@@ -23,7 +23,7 @@ import { IRoomEncryption } from "../RoomList";
 import { IDevice } from "../deviceinfo";
 import { ICrossSigningInfo } from "../CrossSigning";
 import { PrefixedLogger } from "../../logger";
-import { InboundGroupSessionData } from "../../@types/partials";
+import { InboundGroupSessionData } from "../OlmDevice";
 import { IEncryptedPayload } from "../aes";

 /**
@@ -125,7 +125,7 @@ export interface CryptoStore {
    addSharedHistoryInboundGroupSession(roomId: string, senderKey: string, sessionId: string, txn?: unknown): void;
    getSharedHistoryInboundGroupSessions(
        roomId: string,
-        txn?: IDBTransaction,
+        txn?: unknown,
    ): Promise<[senderKey: string, sessionId: string][]>;

    // Session key backups
@@ -30,7 +30,7 @@ import { IRoomKeyRequestBody } from "../index";
 import { ICrossSigningKey } from "../../client";
 import { IOlmDevice } from "../algorithms/megolm";
 import { IRoomEncryption } from "../RoomList";
-import { InboundGroupSessionData } from "../../@types/partials";
+import { InboundGroupSessionData } from "../OlmDevice";
 import { IEncryptedPayload } from "../aes";

 export const VERSION = 10;
@@ -34,7 +34,7 @@ import { IRoomKeyRequestBody } from "../index";
 import { ICrossSigningKey } from "../../client";
 import { IOlmDevice } from "../algorithms/megolm";
 import { IRoomEncryption } from "../RoomList";
-import { InboundGroupSessionData } from "../../@types/partials";
+import { InboundGroupSessionData } from "../OlmDevice";
 import { IEncryptedPayload } from "../aes";

 /**
@@ -20,7 +20,7 @@ import { IDeviceData, IProblem, ISession, ISessionInfo, IWithheld, Mode } from "
 import { IOlmDevice } from "../algorithms/megolm";
 import { IRoomEncryption } from "../RoomList";
 import { ICrossSigningKey } from "../../client";
-import { InboundGroupSessionData } from "../../@types/partials";
+import { InboundGroupSessionData } from "../OlmDevice";
 import { IEncryptedPayload } from "../aes";

 /**
@@ -30,7 +30,7 @@ import { IRoomKeyRequestBody } from "../index";
 import { ICrossSigningKey } from "../../client";
 import { IOlmDevice } from "../algorithms/megolm";
 import { IRoomEncryption } from "../RoomList";
-import { InboundGroupSessionData } from "../../@types/partials";
+import { InboundGroupSessionData } from "../OlmDevice";
 import { IEncryptedPayload } from "../aes";

 /**
@@ -25,18 +25,33 @@ import { EventEmitter } from 'events';
 import { logger } from '../../logger';
 import { DeviceInfo } from '../deviceinfo';
 import { newTimeoutError } from "./Error";
-import { requestKeysDuringVerification } from "../CrossSigning";
+import { KeysDuringVerification, requestKeysDuringVerification } from "../CrossSigning";
+import { IVerificationChannel } from "./request/Channel";
+import { MatrixClient } from "../../client";
+import { VerificationRequest } from "./request/VerificationRequest";

 const timeoutException = new Error("Verification timed out");

 export class SwitchStartEventError extends Error {
-    constructor(startEvent) {
+    constructor(public readonly startEvent: MatrixEvent) {
        super();
-        this.startEvent = startEvent;
    }
 }

+export type KeyVerifier = (keyId: string, device: DeviceInfo, keyInfo: string) => void;
+
 export class VerificationBase extends EventEmitter {
+    private cancelled = false;
+    private _done = false;
+    private promise: Promise<void> = null;
+    private transactionTimeoutTimer: number = null;
+    protected expectedEvent: string;
+    private resolve: () => void;
+    private reject: (e: Error | MatrixEvent) => void;
+    private resolveEvent: (e: MatrixEvent) => void;
+    private rejectEvent: (e: Error) => void;
+    private started: boolean;
+
    /**
     * Base class for verification methods.
     *
@@ -64,22 +79,18 @@ export class VerificationBase extends EventEmitter {
     * @param {object} [request] the key verification request object related to
     * this verification, if any
     */
-    constructor(channel, baseApis, userId, deviceId, startEvent, request) {
+    constructor(
+        public readonly channel: IVerificationChannel,
+        public readonly baseApis: MatrixClient,
+        public readonly userId: string,
+        public readonly deviceId: string,
+        public startEvent: MatrixEvent,
+        public readonly request: VerificationRequest,
+    ) {
        super();
-        this._channel = channel;
-        this._baseApis = baseApis;
-        this.userId = userId;
-        this.deviceId = deviceId;
-        this.startEvent = startEvent;
-        this.request = request;
-
-        this.cancelled = false;
-        this._done = false;
-        this._promise = null;
-        this._transactionTimeoutTimer = null;
    }

-    get initiatedByMe() {
+    public get initiatedByMe(): boolean {
        // if there is no start event yet,
        // we probably want to send it,
        // which happens if we initiate
@@ -88,16 +99,20 @@ export class VerificationBase extends EventEmitter {
        }
        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();
    }

-    _resetTimer() {
+    public get hasBeenCancelled(): boolean {
+        return this.cancelled;
+    }
+
+    private resetTimer(): void {
        logger.info("Refreshing/starting the verification transaction timeout timer");
-        if (this._transactionTimeoutTimer !== null) {
-            clearTimeout(this._transactionTimeoutTimer);
+        if (this.transactionTimeoutTimer !== null) {
+            clearTimeout(this.transactionTimeoutTimer);
        }
-        this._transactionTimeoutTimer = setTimeout(() => {
+        this.transactionTimeoutTimer = setTimeout(() => {
            if (!this._done && !this.cancelled) {
                logger.info("Triggering verification timeout");
                this.cancel(timeoutException);
@@ -105,18 +120,18 @@ export class VerificationBase extends EventEmitter {
        }, 10 * 60 * 1000); // 10 minutes
    }

-    _endTimer() {
-        if (this._transactionTimeoutTimer !== null) {
-            clearTimeout(this._transactionTimeoutTimer);
-            this._transactionTimeoutTimer = null;
+    private endTimer(): void {
+        if (this.transactionTimeoutTimer !== null) {
+            clearTimeout(this.transactionTimeoutTimer);
+            this.transactionTimeoutTimer = null;
        }
    }

-    _send(type, uncompletedContent) {
-        return this._channel.send(type, uncompletedContent);
+    protected send(type: string, uncompletedContent: Record<string, any>): Promise<void> {
+        return this.channel.send(type, uncompletedContent);
    }

-    _waitForEvent(type) {
+    protected waitForEvent(type: string): Promise<MatrixEvent> {
        if (this._done) {
            return Promise.reject(new Error("Verification is already done"));
        }
@@ -125,24 +140,24 @@ export class VerificationBase extends EventEmitter {
            return Promise.resolve(existingEvent);
        }

-        this._expectedEvent = type;
+        this.expectedEvent = type;
        return new Promise((resolve, reject) => {
-            this._resolveEvent = resolve;
-            this._rejectEvent = reject;
+            this.resolveEvent = resolve;
+            this.rejectEvent = reject;
        });
    }

-    canSwitchStartEvent() {
+    public canSwitchStartEvent(event: MatrixEvent): boolean {
        return false;
    }

-    switchStartEvent(event) {
+    public switchStartEvent(event: MatrixEvent): void {
        if (this.canSwitchStartEvent(event)) {
            logger.log("Verification Base: switching verification start event",
-                { restartingFlow: !!this._rejectEvent });
-            if (this._rejectEvent) {
-                const reject = this._rejectEvent;
-                this._rejectEvent = undefined;
+                { restartingFlow: !!this.rejectEvent });
+            if (this.rejectEvent) {
+                const reject = this.rejectEvent;
+                this.rejectEvent = undefined;
                reject(new SwitchStartEventError(event));
            } else {
                this.startEvent = event;
@@ -150,21 +165,21 @@ export class VerificationBase extends EventEmitter {
        }
    }

-    handleEvent(e) {
+    public handleEvent(e: MatrixEvent): void {
        if (this._done) {
            return;
-        } else if (e.getType() === this._expectedEvent) {
+        } else if (e.getType() === this.expectedEvent) {
            // if we receive an expected m.key.verification.done, then just
            // ignore it, since we don't need to do anything about it
-            if (this._expectedEvent !== "m.key.verification.done") {
-                this._expectedEvent = undefined;
-                this._rejectEvent = undefined;
-                this._resetTimer();
-                this._resolveEvent(e);
+            if (this.expectedEvent !== "m.key.verification.done") {
+                this.expectedEvent = undefined;
+                this.rejectEvent = undefined;
+                this.resetTimer();
+                this.resolveEvent(e);
            }
        } else if (e.getType() === "m.key.verification.cancel") {
-            const reject = this._reject;
-            this._reject = undefined;
+            const reject = this.reject;
+            this.reject = undefined;
            // there is only promise to reject if verify has been called
            if (reject) {
                const content = e.getContent();
@@ -172,36 +187,36 @@ export class VerificationBase extends EventEmitter {
                reject(new Error(`Other side cancelled verification ` +
                    `because ${reason} (${code})`));
            }
-        } else if (this._expectedEvent) {
+        } else if (this.expectedEvent) {
            // only cancel if there is an event expected.
            // if there is no event expected, it means verify() wasn't called
            // 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
+                "Unexpected message: expecting " + this.expectedEvent
                    + " but got " + e.getType(),
            );
-            this._expectedEvent = undefined;
-            if (this._rejectEvent) {
-                const reject = this._rejectEvent;
-                this._rejectEvent = undefined;
+            this.expectedEvent = undefined;
+            if (this.rejectEvent) {
+                const reject = this.rejectEvent;
+                this.rejectEvent = undefined;
                reject(exception);
            }
            this.cancel(exception);
        }
    }

-    done() {
-        this._endTimer(); // always kill the activity timer
+    public done(): Promise<KeysDuringVerification | void> {
+        this.endTimer(); // always kill the activity timer
        if (!this._done) {
            this.request.onVerifierFinished();
-            this._resolve();
-            return requestKeysDuringVerification(this._baseApis, this.userId, this.deviceId);
+            this.resolve();
+            return requestKeysDuringVerification(this.baseApis, this.userId, this.deviceId);
        }
    }

-    cancel(e) {
-        this._endTimer(); // always kill the activity timer
+    public cancel(e: Error | MatrixEvent): void {
+        this.endTimer(); // always kill the activity timer
        if (!this._done) {
            this.cancelled = true;
            this.request.onVerifierCancelled();
@@ -210,7 +225,7 @@ export class VerificationBase extends EventEmitter {
                // cancelled by the other user)
                if (e === timeoutException) {
                    const timeoutEvent = newTimeoutError();
-                    this._send(timeoutEvent.getType(), timeoutEvent.getContent());
+                    this.send(timeoutEvent.getType(), timeoutEvent.getContent());
                } else if (e instanceof MatrixEvent) {
                    const sender = e.getSender();
                    if (sender !== this.userId) {
@@ -219,29 +234,29 @@ export class VerificationBase extends EventEmitter {
                            content.code = content.code || "m.unknown";
                            content.reason = content.reason || content.body
                                || "Unknown reason";
-                            this._send("m.key.verification.cancel", content);
+                            this.send("m.key.verification.cancel", content);
                        } else {
-                            this._send("m.key.verification.cancel", {
+                            this.send("m.key.verification.cancel", {
                                code: "m.unknown",
                                reason: content.body || "Unknown reason",
                            });
                        }
                    }
                } else {
-                    this._send("m.key.verification.cancel", {
+                    this.send("m.key.verification.cancel", {
                        code: "m.unknown",
                        reason: e.toString(),
                    });
                }
            }
-            if (this._promise !== null) {
+            if (this.promise !== null) {
                // when we cancel without a promise, we end up with a promise
                // but no reject function. If cancel is called again, we'd error.
-                if (this._reject) this._reject(e);
+                if (this.reject) this.reject(e);
            } else {
                // FIXME: this causes an "Uncaught promise" console message
                // if nothing ends up chaining this promise.
-                this._promise = Promise.reject(e);
+                this.promise = Promise.reject(e);
            }
            // Also emit a 'cancel' event that the app can listen for to detect cancellation
            // before calling verify()
@@ -255,31 +270,32 @@ export class VerificationBase extends EventEmitter {
     * @returns {Promise} Promise which resolves when the verification has
     *     completed.
     */
-    verify() {
-        if (this._promise) return this._promise;
+    public verify(): Promise<void> {
+        if (this.promise) return this.promise;

-        this._promise = new Promise((resolve, reject) => {
-            this._resolve = (...args) => {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = (...args) => {
                this._done = true;
-                this._endTimer();
+                this.endTimer();
                resolve(...args);
            };
-            this._reject = (...args) => {
+            this.reject = (e: Error) => {
                this._done = true;
-                this._endTimer();
-                reject(...args);
+                this.endTimer();
+                reject(e);
            };
        });
-        if (this._doVerification && !this._started) {
-            this._started = true;
-            this._resetTimer(); // restart the timeout
-            Promise.resolve(this._doVerification())
-                .then(this.done.bind(this), this.cancel.bind(this));
+        if (this.doVerification && !this.started) {
+            this.started = true;
+            this.resetTimer(); // restart the timeout
+            Promise.resolve(this.doVerification()).then(this.done.bind(this), this.cancel.bind(this));
        }
-        return this._promise;
+        return this.promise;
    }

-    async _verifyKeys(userId, keys, verifier) {
+    protected doVerification?: () => Promise<void>;
+
+    protected async verifyKeys(userId: string, keys: Record<string, string>, verifier: KeyVerifier): Promise<void> {
        // we try to verify all the keys that we're told about, but we might
        // not know about all of them, so keep track of the keys that we know
        // about, and ignore the rest
@@ -287,15 +303,14 @@ export class VerificationBase extends EventEmitter {

        for (const [keyId, keyInfo] of Object.entries(keys)) {
            const deviceId = keyId.split(':', 2)[1];
-            const device = this._baseApis.getStoredDevice(userId, deviceId);
+            const device = this.baseApis.getStoredDevice(userId, deviceId);
            if (device) {
-                await verifier(keyId, device, keyInfo);
+                verifier(keyId, device, keyInfo);
                verifiedDevices.push(deviceId);
            } else {
-                const crossSigningInfo = this._baseApis.crypto.deviceList
-                      .getStoredCrossSigningForUser(userId);
+                const crossSigningInfo = this.baseApis.crypto.deviceList.getStoredCrossSigningForUser(userId);
                if (crossSigningInfo && crossSigningInfo.getId() === deviceId) {
-                    await verifier(keyId, DeviceInfo.fromStorage({
+                    verifier(keyId, DeviceInfo.fromStorage({
                        keys: {
                            [keyId]: deviceId,
                        },
@@ -323,7 +338,11 @@ export class VerificationBase extends EventEmitter {
        // to upload each signature in a separate API call which is silly because the
        // API supports as many signatures as you like.
        for (const deviceId of verifiedDevices) {
-            await this._baseApis.setDeviceVerified(userId, deviceId);
+            await this.baseApis.setDeviceVerified(userId, deviceId);
        }
    }
+
+    public get events(): string[] | undefined {
+        return undefined;
+    }
 }
@@ -1,5 +1,5 @@
 /*
-Copyright 2018 New Vector Ltd
+Copyright 2018 - 2021 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.
@@ -22,17 +22,17 @@ limitations under the License.

 import { MatrixEvent } from "../../models/event";

-export function newVerificationError(code, reason, extradata) {
-    const content = Object.assign({}, { code, reason }, extradata);
+export function newVerificationError(code: string, reason: string, extraData: Record<string, any>): MatrixEvent {
+    const content = Object.assign({}, { code, reason }, extraData);
    return new MatrixEvent({
        type: "m.key.verification.cancel",
        content,
    });
 }

-export function errorFactory(code, reason) {
-    return function(extradata) {
-        return newVerificationError(code, reason, extradata);
+export function errorFactory(code: string, reason: string): (extraData?: Record<string, any>) => MatrixEvent {
+    return function(extraData?: Record<string, any>) {
+        return newVerificationError(code, reason, extraData);
    };
 }

@@ -84,7 +84,7 @@ export const newInvalidMessageError = errorFactory(
    "m.invalid_message", "Invalid message",
 );

-export function errorFromEvent(event) {
+export function errorFromEvent(event: MatrixEvent): { code: string, reason: string } {
    const content = event.getContent();
    if (content) {
        const { code, reason } = content;
@@ -21,23 +21,35 @@ limitations under the License.
 */

 import { VerificationBase as Base } from "./Base";
+import { IVerificationChannel } from "./request/Channel";
+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 {
-    static factory(...args) {
-        return new IllegalMethod(...args);
+    public static factory(
+        channel: IVerificationChannel,
+        baseApis: MatrixClient,
+        userId: string,
+        deviceId: string,
+        startEvent: MatrixEvent,
+        request: VerificationRequest,
+    ): IllegalMethod {
+        return new IllegalMethod(channel, baseApis, userId, deviceId, startEvent, request);
    }

-    static get NAME() {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public static get NAME(): string {
        // Typically the name will be something else, but to complete
        // the contract we offer a default one here.
        return "org.matrix.illegal_method";
    }

-    async _doVerification() {
+    protected doVerification = async (): Promise<void> => {
        throw new Error("Verification is not possible with this method");
-    }
+    };
 }
@@ -1,6 +1,5 @@
 /*
-Copyright 2018 New Vector Ltd
-Copyright 2020 The Matrix.org Foundation C.I.C.
+Copyright 2018 - 2021 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.
@@ -21,12 +20,13 @@ limitations under the License.
 */

 import { VerificationBase as Base } from "./Base";
-import {
-    newKeyMismatchError,
-    newUserCancelledError,
-} from './Error';
-import { encodeUnpaddedBase64, decodeBase64 } from "../olmlib";
+import { newKeyMismatchError, newUserCancelledError } from './Error';
+import { decodeBase64, encodeUnpaddedBase64 } from "../olmlib";
 import { logger } from '../../logger';
+import { VerificationRequest } from "./request/VerificationRequest";
+import { MatrixClient } from "../../client";
+import { IVerificationChannel } from "./request/Channel";
+import { MatrixEvent } from "../../models/event";

 export const SHOW_QR_CODE_METHOD = "m.qr_code.show.v1";
 export const SCAN_QR_CODE_METHOD = "m.qr_code.scan.v1";
@@ -36,15 +36,28 @@ export const SCAN_QR_CODE_METHOD = "m.qr_code.scan.v1";
 * @extends {module:crypto/verification/Base}
 */
 export class ReciprocateQRCode extends Base {
-    static factory(...args) {
-        return new ReciprocateQRCode(...args);
+    public reciprocateQREvent: {
+        confirm(): void;
+        cancel(): void;
+    };
+
+    public static factory(
+        channel: IVerificationChannel,
+        baseApis: MatrixClient,
+        userId: string,
+        deviceId: string,
+        startEvent: MatrixEvent,
+        request: VerificationRequest,
+    ): ReciprocateQRCode {
+        return new ReciprocateQRCode(channel, baseApis, userId, deviceId, startEvent, request);
    }

-    static get NAME() {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public static get NAME(): string {
        return "m.reciprocate.v1";
    }

-    async _doVerification() {
+    protected doVerification = async (): Promise<void> => {
        if (!this.startEvent) {
            // TODO: Support scanning QR codes
            throw new Error("It is not currently possible to start verification" +
@@ -58,7 +71,7 @@ export class ReciprocateQRCode extends Base {
        }

        // 2. ask if other user shows shield as well
-        await new Promise((resolve, reject) => {
+        await new Promise<void>((resolve, reject) => {
            this.reciprocateQREvent = {
                confirm: resolve,
                cancel: () => reject(newUserCancelledError()),
@@ -67,21 +80,21 @@ export class ReciprocateQRCode extends Base {
        });

        // 3. determine key to sign / mark as trusted
-        const keys = {};
+        const keys: Record<string, string> = {};

        switch (qrCodeData.mode) {
-            case MODE_VERIFY_OTHER_USER: {
+            case Mode.VerifyOtherUser: {
                // add master key to keys to be signed, only if we're not doing self-verification
                const masterKey = qrCodeData.otherUserMasterKey;
                keys[`ed25519:${masterKey}`] = masterKey;
                break;
            }
-            case MODE_VERIFY_SELF_TRUSTED: {
+            case Mode.VerifySelfTrusted: {
                const deviceId = this.request.targetDevice.deviceId;
                keys[`ed25519:${deviceId}`] = qrCodeData.otherDeviceKey;
                break;
            }
-            case MODE_VERIFY_SELF_UNTRUSTED: {
+            case Mode.VerifySelfUntrusted: {
                const masterKey = qrCodeData.myMasterKey;
                keys[`ed25519:${masterKey}`] = masterKey;
                break;
@@ -89,7 +102,7 @@ export class ReciprocateQRCode extends Base {
        }

        // 4. sign the key (or mark own MSK as verified in case of MODE_VERIFY_SELF_TRUSTED)
-        await this._verifyKeys(this.userId, keys, (keyId, device, keyInfo) => {
+        await this.verifyKeys(this.userId, keys, (keyId, device, keyInfo) => {
            // make sure the device has the expected keys
            const targetKey = keys[keyId];
            if (!targetKey) throw newKeyMismatchError();
@@ -108,103 +121,88 @@ export class ReciprocateQRCode extends Base {
                }
            }
        });
-    }
+    };
 }

 const CODE_VERSION = 0x02; // the version of binary QR codes we support
 const BINARY_PREFIX = "MATRIX"; // ASCII, used to prefix the binary format
-const MODE_VERIFY_OTHER_USER = 0x00; // Verifying someone who isn't us
-const MODE_VERIFY_SELF_TRUSTED = 0x01; // We trust the master key
-const MODE_VERIFY_SELF_UNTRUSTED = 0x02; // We do not trust the master key
+
+enum Mode {
+    VerifyOtherUser = 0x00, // Verifying someone who isn't us
+    VerifySelfTrusted = 0x01, // We trust the master key
+    VerifySelfUntrusted = 0x02, // We do not trust the master key
+}
+
+interface IQrData {
+    prefix: string;
+    version: number;
+    mode: Mode;
+    transactionId: string;
+    firstKeyB64: string;
+    secondKeyB64: string;
+    secretB64: string;
+}

 export class QRCodeData {
    constructor(
-        mode, sharedSecret, otherUserMasterKey,
-        otherDeviceKey, myMasterKey, buffer,
-    ) {
-        this._sharedSecret = sharedSecret;
-        this._mode = mode;
-        this._otherUserMasterKey = otherUserMasterKey;
-        this._otherDeviceKey = otherDeviceKey;
-        this._myMasterKey = myMasterKey;
-        this._buffer = buffer;
-    }
+        public readonly mode: Mode,
+        private readonly sharedSecret: string,
+        // only set when mode is MODE_VERIFY_OTHER_USER, master key of other party at time of generating QR code
+        public readonly otherUserMasterKey: string | undefined,
+        // only set when mode is MODE_VERIFY_SELF_TRUSTED, device key of other party at time of generating QR code
+        public readonly otherDeviceKey: string | undefined,
+        // only set when mode is MODE_VERIFY_SELF_UNTRUSTED, own master key at time of generating QR code
+        public readonly myMasterKey: string | undefined,
+        private readonly buffer: Buffer,
+    ) {}

-    static async create(request, client) {
-        const sharedSecret = QRCodeData._generateSharedSecret();
-        const mode = QRCodeData._determineMode(request, client);
+    public static async create(request: VerificationRequest, client: MatrixClient): Promise<QRCodeData> {
+        const sharedSecret = QRCodeData.generateSharedSecret();
+        const mode = QRCodeData.determineMode(request, client);
        let otherUserMasterKey = null;
        let otherDeviceKey = null;
        let myMasterKey = null;
-        if (mode === MODE_VERIFY_OTHER_USER) {
+        if (mode === Mode.VerifyOtherUser) {
            const otherUserCrossSigningInfo =
                client.getStoredCrossSigningForUser(request.otherUserId);
            otherUserMasterKey = otherUserCrossSigningInfo.getId("master");
-        } else if (mode === MODE_VERIFY_SELF_TRUSTED) {
-            otherDeviceKey = await QRCodeData._getOtherDeviceKey(request, client);
-        } else if (mode === MODE_VERIFY_SELF_UNTRUSTED) {
+        } else if (mode === Mode.VerifySelfTrusted) {
+            otherDeviceKey = await QRCodeData.getOtherDeviceKey(request, client);
+        } else if (mode === Mode.VerifySelfUntrusted) {
            const myUserId = client.getUserId();
            const myCrossSigningInfo = client.getStoredCrossSigningForUser(myUserId);
            myMasterKey = myCrossSigningInfo.getId("master");
        }
-        const qrData = QRCodeData._generateQrData(
+        const qrData = QRCodeData.generateQrData(
            request, client, mode,
            sharedSecret,
            otherUserMasterKey,
            otherDeviceKey,
            myMasterKey,
        );
-        const buffer = QRCodeData._generateBuffer(qrData);
+        const buffer = QRCodeData.generateBuffer(qrData);
        return new QRCodeData(mode, sharedSecret,
            otherUserMasterKey, otherDeviceKey, myMasterKey, buffer);
    }

-    get buffer() {
-        return this._buffer;
-    }
-
-    get mode() {
-        return this._mode;
-    }
-
-    /**
-     * only set when mode is MODE_VERIFY_SELF_TRUSTED
-     * @return {string} device key of other party at time of generating QR code
-     */
-    get otherDeviceKey() {
-        return this._otherDeviceKey;
-    }
-
-    /**
-     * only set when mode is MODE_VERIFY_OTHER_USER
-     * @return {string} master key of other party at time of generating QR code
-     */
-    get otherUserMasterKey() {
-        return this._otherUserMasterKey;
-    }
-
-    /**
-     * only set when mode is MODE_VERIFY_SELF_UNTRUSTED
-     * @return {string} own master key at time of generating QR code
-     */
-    get myMasterKey() {
-        return this._myMasterKey;
-    }
-
    /**
     * The unpadded base64 encoded shared secret.
     */
-    get encodedSharedSecret() {
-        return this._sharedSecret;
+    public get encodedSharedSecret(): string {
+        return this.sharedSecret;
    }

-    static _generateSharedSecret() {
+    public getBuffer(): Buffer {
+        return this.buffer;
+    }
+
+    private static generateSharedSecret(): string {
        const secretBytes = new Uint8Array(11);
        global.crypto.getRandomValues(secretBytes);
        return encodeUnpaddedBase64(secretBytes);
    }

-    static async _getOtherDeviceKey(request, client) {
+    private static async getOtherDeviceKey(request: VerificationRequest, client: MatrixClient): Promise<string> {
        const myUserId = client.getUserId();
        const otherDevice = request.targetDevice;
        const otherDeviceId = otherDevice ? otherDevice.deviceId : null;
@@ -212,31 +210,35 @@ export class QRCodeData {
        if (!device) {
            throw new Error("could not find device " + otherDeviceId);
        }
-        const key = device.getFingerprint();
-        return key;
+        return device.getFingerprint();
    }

-    static _determineMode(request, client) {
+    private static determineMode(request: VerificationRequest, client: MatrixClient): Mode {
        const myUserId = client.getUserId();
        const otherUserId = request.otherUserId;

-        let mode = MODE_VERIFY_OTHER_USER;
+        let mode = Mode.VerifyOtherUser;
        if (myUserId === otherUserId) {
            // Mode changes depending on whether or not we trust the master cross signing key
            const myTrust = client.checkUserTrust(myUserId);
            if (myTrust.isCrossSigningVerified()) {
-                mode = MODE_VERIFY_SELF_TRUSTED;
+                mode = Mode.VerifySelfTrusted;
            } else {
-                mode = MODE_VERIFY_SELF_UNTRUSTED;
+                mode = Mode.VerifySelfUntrusted;
            }
        }
        return mode;
    }

-    static _generateQrData(request, client, mode,
-        encodedSharedSecret, otherUserMasterKey,
-        otherDeviceKey, myMasterKey,
-    ) {
+    private static generateQrData(
+        request: VerificationRequest,
+        client: MatrixClient,
+        mode: Mode,
+        encodedSharedSecret: string,
+        otherUserMasterKey: string,
+        otherDeviceKey: string,
+        myMasterKey: string,
+    ): IQrData {
        const myUserId = client.getUserId();
        const transactionId = request.channel.transactionId;
        const qrData = {
@@ -251,16 +253,16 @@ export class QRCodeData {

        const myCrossSigningInfo = client.getStoredCrossSigningForUser(myUserId);

-        if (mode === MODE_VERIFY_OTHER_USER) {
+        if (mode === Mode.VerifyOtherUser) {
            // First key is our master cross signing key
            qrData.firstKeyB64 = myCrossSigningInfo.getId("master");
            // Second key is the other user's master cross signing key
            qrData.secondKeyB64 = otherUserMasterKey;
-        } else if (mode === MODE_VERIFY_SELF_TRUSTED) {
+        } else if (mode === Mode.VerifySelfTrusted) {
            // First key is our master cross signing key
            qrData.firstKeyB64 = myCrossSigningInfo.getId("master");
            qrData.secondKeyB64 = otherDeviceKey;
-        } else if (mode === MODE_VERIFY_SELF_UNTRUSTED) {
+        } else if (mode === Mode.VerifySelfUntrusted) {
            // First key is our device's key
            qrData.firstKeyB64 = client.getDeviceEd25519Key();
            // Second key is what we think our master cross signing key is
@@ -269,7 +271,7 @@ export class QRCodeData {
        return qrData;
    }

-    static _generateBuffer(qrData) {
+    private static generateBuffer(qrData: IQrData): Buffer {
        let buf = Buffer.alloc(0); // we'll concat our way through life

        const appendByte = (b) => {
@@ -1,5 +1,5 @@
 /*
-Copyright 2018 New Vector Ltd
+Copyright 2018 - 2021 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.
@@ -29,6 +29,8 @@ import {
    newUserCancelledError,
 } from './Error';
 import { logger } from '../../logger';
+import { Utility, SAS as OlmSAS } from "@matrix-org/olm";
+import { IContent, MatrixEvent } from "../../models/event";

 const START_TYPE = "m.key.verification.start";

@@ -38,7 +40,7 @@ const EVENTS = [
    "m.key.verification.mac",
 ];

-let olmutil;
+let olmutil: Utility;

 const newMismatchedSASError = errorFactory(
    "m.mismatched_sas", "Mismatched short authentication string",
@@ -48,7 +50,7 @@ const newMismatchedCommitmentError = errorFactory(
    "m.mismatched_commitment", "Mismatched commitment",
 );

-function generateDecimalSas(sasBytes) {
+function generateDecimalSas(sasBytes: number[]): [number, number, number] {
    /**
     *      +--------+--------+--------+--------+--------+
     *      | Byte 0 | Byte 1 | Byte 2 | Byte 3 | Byte 4 |
@@ -64,7 +66,9 @@ function generateDecimalSas(sasBytes) {
    ];
 }

-const emojiMapping = [
+type EmojiMapping = [emoji: string, name: string];
+
+const emojiMapping: EmojiMapping[] = [
    ["🐶", "dog"],        //  0
    ["🐱", "cat"],        //  1
    ["🦁", "lion"],       //  2
@@ -131,7 +135,7 @@ const emojiMapping = [
    ["📌", "pin"],        // 63
 ];

-function generateEmojiSas(sasBytes) {
+function generateEmojiSas(sasBytes: number[]): EmojiMapping[] {
    const emojis = [
        // just like base64 encoding
        sasBytes[0] >> 2,
@@ -151,8 +155,20 @@ const sasGenerators = {
    emoji: generateEmojiSas,
 };

-function generateSas(sasBytes, methods) {
-    const sas = {};
+export interface IGeneratedSas {
+    decimal?: [number, number, number];
+    emoji?: EmojiMapping[];
+}
+
+export interface ISasEvent {
+    sas: IGeneratedSas;
+    confirm(): Promise<void>;
+    cancel(): void;
+    mismatch(): void;
+}
+
+function generateSas(sasBytes: number[], methods: string[]): IGeneratedSas {
+    const sas: IGeneratedSas = {};
    for (const method of methods) {
        if (method in sasGenerators) {
            sas[method] = sasGenerators[method](sasBytes);
@@ -166,7 +182,7 @@ const macMethods = {
    "hmac-sha256": "calculate_mac_long_kdf",
 };

-function calculateMAC(olmSAS, method) {
+function calculateMAC(olmSAS: OlmSAS, method: string) {
    return function(...args) {
        const macFunction = olmSAS[macMethods[method]];
        const mac = macFunction.apply(olmSAS, args);
@@ -176,23 +192,23 @@ function calculateMAC(olmSAS, method) {
 }

 const calculateKeyAgreement = {
-    "curve25519-hkdf-sha256": function(sas, olmSAS, bytes) {
-        const ourInfo = `${sas._baseApis.getUserId()}|${sas._baseApis.deviceId}|`
+    "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;
+              + sas.channel.transactionId;
        return olmSAS.generate_bytes(sasInfo, bytes);
    },
-    "curve25519": function(sas, olmSAS, bytes) {
-        const ourInfo = `${sas._baseApis.getUserId()}${sas._baseApis.deviceId}`;
+    "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;
+              + sas.channel.transactionId;
        return olmSAS.generate_bytes(sasInfo, bytes);
    },
 };
@@ -211,7 +227,7 @@ const HASHES_SET = new Set(HASHES_LIST);
 const MAC_SET = new Set(MAC_LIST);
 const SAS_SET = new Set(SAS_LIST);

-function intersection(anArray, aSet) {
+function intersection<T>(anArray: T[], aSet: Set<T>): T[] {
    return anArray instanceof Array ? anArray.filter(x => aSet.has(x)) : [];
 }

@@ -220,28 +236,34 @@ function intersection(anArray, aSet) {
 * @extends {module:crypto/verification/Base}
 */
 export class SAS extends Base {
-    static get NAME() {
+    private waitingForAccept: boolean;
+    public ourSASPubKey: string;
+    public theirSASPubKey: string;
+    public sasEvent: ISasEvent;
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public static get NAME(): string {
        return "m.sas.v1";
    }

-    get events() {
+    public get events(): string[] {
        return EVENTS;
    }

-    async _doVerification() {
+    protected doVerification = async (): Promise<void> => {
        await global.Olm.init();
        olmutil = olmutil || new global.Olm.Utility();

        // make sure user's keys are downloaded
-        await this._baseApis.downloadKeys([this.userId]);
+        await this.baseApis.downloadKeys([this.userId]);

        let retry = false;
        do {
            try {
                if (this.initiatedByMe) {
-                    return await this._doSendVerification();
+                    return await this.doSendVerification();
                } else {
-                    return await this._doRespondVerification();
+                    return await this.doRespondVerification();
                }
            } catch (err) {
                if (err instanceof SwitchStartEventError) {
@@ -253,38 +275,37 @@ export class SAS extends Base {
                }
            }
        } while (retry);
-    }
+    };

-    canSwitchStartEvent(event) {
+    public canSwitchStartEvent(event: MatrixEvent): boolean {
        if (event.getType() !== START_TYPE) {
            return false;
        }
        const content = event.getContent();
-        return content && content.method === SAS.NAME &&
-            this._waitingForAccept;
+        return content && content.method === SAS.NAME && this.waitingForAccept;
    }

-    async _sendStart() {
-        const startContent = this._channel.completeContent(START_TYPE, {
+    private async sendStart(): Promise<Record<string, any>> {
+        const startContent = this.channel.completeContent(START_TYPE, {
            method: SAS.NAME,
-            from_device: this._baseApis.deviceId,
+            from_device: this.baseApis.deviceId,
            key_agreement_protocols: KEY_AGREEMENT_LIST,
            hashes: HASHES_LIST,
            message_authentication_codes: MAC_LIST,
            // FIXME: allow app to specify what SAS methods can be used
            short_authentication_string: SAS_LIST,
        });
-        await this._channel.sendCompleted(START_TYPE, startContent);
+        await this.channel.sendCompleted(START_TYPE, startContent);
        return startContent;
    }

-    async _doSendVerification() {
-        this._waitingForAccept = true;
+    private async doSendVerification(): Promise<void> {
+        this.waitingForAccept = true;
        let startContent;
        if (this.startEvent) {
-            startContent = this._channel.completedContentFromEvent(this.startEvent);
+            startContent = this.channel.completedContentFromEvent(this.startEvent);
        } else {
-            startContent = await this._sendStart();
+            startContent = await this.sendStart();
        }

        // we might have switched to a different start event,
@@ -297,9 +318,9 @@ export class SAS extends Base {

        let e;
        try {
-            e = await this._waitForEvent("m.key.verification.accept");
+            e = await this.waitForEvent("m.key.verification.accept");
        } finally {
-            this._waitingForAccept = false;
+            this.waitingForAccept = false;
        }
        let content = e.getContent();
        const sasMethods
@@ -319,11 +340,11 @@ export class SAS extends Base {
        const olmSAS = new global.Olm.SAS();
        try {
            this.ourSASPubKey = olmSAS.get_pubkey();
-            await this._send("m.key.verification.key", {
+            await this.send("m.key.verification.key", {
                key: this.ourSASPubKey,
            });

-            e = await this._waitForEvent("m.key.verification.key");
+            e = await this.waitForEvent("m.key.verification.key");
            // FIXME: make sure event is properly formed
            content = e.getContent();
            const commitmentStr = content.key + anotherjson.stringify(startContent);
@@ -335,12 +356,12 @@ export class SAS extends Base {
            olmSAS.set_their_key(content.key);

            const sasBytes = calculateKeyAgreement[keyAgreement](this, olmSAS, 6);
-            const verifySAS = new Promise((resolve, reject) => {
+            const verifySAS = new Promise<void>((resolve, reject) => {
                this.sasEvent = {
                    sas: generateSas(sasBytes, sasMethods),
                    confirm: async () => {
                        try {
-                            await this._sendMAC(olmSAS, macMethod);
+                            await this.sendMAC(olmSAS, macMethod);
                            resolve();
                        } catch (err) {
                            reject(err);
@@ -353,54 +374,45 @@ export class SAS extends Base {
            });

            [e] = await Promise.all([
-                this._waitForEvent("m.key.verification.mac")
+                this.waitForEvent("m.key.verification.mac")
                    .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 = "m.key.verification.done";
+                        this.expectedEvent = "m.key.verification.done";
                        return e;
                    }),
                verifySAS,
            ]);
            content = e.getContent();
-            await this._checkMAC(olmSAS, content, macMethod);
+            await this.checkMAC(olmSAS, content, macMethod);
        } finally {
            olmSAS.free();
        }
    }

-    async _doRespondVerification() {
+    private async doRespondVerification(): Promise<void> {
        // as m.related_to is not included in the encrypted content in e2e rooms,
        // we need to make sure it is added
-        let content = this._channel.completedContentFromEvent(this.startEvent);
+        let content = this.channel.completedContentFromEvent(this.startEvent);

        // Note: we intersect using our pre-made lists, rather than the sets,
        // so that the result will be in our order of preference.  Then
        // fetching the first element from the array will give our preferred
        // method out of the ones offered by the other party.
-        const keyAgreement
-              = intersection(
-                  KEY_AGREEMENT_LIST, new Set(content.key_agreement_protocols),
-              )[0];
-        const hashMethod
-              = intersection(HASHES_LIST, new Set(content.hashes))[0];
-        const macMethod
-              = intersection(MAC_LIST, new Set(content.message_authentication_codes))[0];
+        const keyAgreement = intersection(KEY_AGREEMENT_LIST, new Set(content.key_agreement_protocols))[0];
+        const hashMethod = intersection(HASHES_LIST, new Set(content.hashes))[0];
+        const macMethod = intersection(MAC_LIST, new Set(content.message_authentication_codes))[0];
        // FIXME: allow app to specify what SAS methods can be used
-        const sasMethods
-              = intersection(content.short_authentication_string, SAS_SET);
-        if (!(keyAgreement !== undefined
-              && hashMethod !== undefined
-              && macMethod !== undefined
-              && sasMethods.length)) {
+        const sasMethods = intersection(content.short_authentication_string, SAS_SET);
+        if (!(keyAgreement !== undefined && hashMethod !== undefined && macMethod !== undefined && sasMethods.length)) {
            throw newUnknownMethodError();
        }

        const olmSAS = new global.Olm.SAS();
        try {
            const commitmentStr = olmSAS.get_pubkey() + anotherjson.stringify(content);
-            await this._send("m.key.verification.accept", {
+            await this.send("m.key.verification.accept", {
                key_agreement_protocol: keyAgreement,
                hash: hashMethod,
                message_authentication_code: macMethod,
@@ -409,23 +421,23 @@ export class SAS extends Base {
                commitment: olmutil.sha256(commitmentStr),
            });

-            let e = await this._waitForEvent("m.key.verification.key");
+            let e = await this.waitForEvent("m.key.verification.key");
            // FIXME: make sure event is properly formed
            content = e.getContent();
            this.theirSASPubKey = content.key;
            olmSAS.set_their_key(content.key);
            this.ourSASPubKey = olmSAS.get_pubkey();
-            await this._send("m.key.verification.key", {
+            await this.send("m.key.verification.key", {
                key: this.ourSASPubKey,
            });

            const sasBytes = calculateKeyAgreement[keyAgreement](this, olmSAS, 6);
-            const verifySAS = new Promise((resolve, reject) => {
+            const verifySAS = new Promise<void>((resolve, reject) => {
                this.sasEvent = {
                    sas: generateSas(sasBytes, sasMethods),
                    confirm: async () => {
                        try {
-                            await this._sendMAC(olmSAS, macMethod);
+                            await this.sendMAC(olmSAS, macMethod);
                            resolve();
                        } catch (err) {
                            reject(err);
@@ -438,39 +450,39 @@ export class SAS extends Base {
            });

            [e] = await Promise.all([
-                this._waitForEvent("m.key.verification.mac")
+                this.waitForEvent("m.key.verification.mac")
                    .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 = "m.key.verification.done";
+                        this.expectedEvent = "m.key.verification.done";
                        return e;
                    }),
                verifySAS,
            ]);
            content = e.getContent();
-            await this._checkMAC(olmSAS, content, macMethod);
+            await this.checkMAC(olmSAS, content, macMethod);
        } finally {
            olmSAS.free();
        }
    }

-    _sendMAC(olmSAS, method) {
+    private sendMAC(olmSAS: OlmSAS, method: string): Promise<void> {
        const mac = {};
        const keyList = [];
        const baseInfo = "MATRIX_KEY_VERIFICATION_MAC"
-              + this._baseApis.getUserId() + this._baseApis.deviceId
+              + this.baseApis.getUserId() + this.baseApis.deviceId
              + this.userId + this.deviceId
-              + this._channel.transactionId;
+              + this.channel.transactionId;

-        const deviceKeyId = `ed25519:${this._baseApis.deviceId}`;
+        const deviceKeyId = `ed25519:${this.baseApis.deviceId}`;
        mac[deviceKeyId] = calculateMAC(olmSAS, method)(
-            this._baseApis.getDeviceEd25519Key(),
+            this.baseApis.getDeviceEd25519Key(),
            baseInfo + deviceKeyId,
        );
        keyList.push(deviceKeyId);

-        const crossSigningId = this._baseApis.getCrossSigningId();
+        const crossSigningId = this.baseApis.getCrossSigningId();
        if (crossSigningId) {
            const crossSigningKeyId = `ed25519:${crossSigningId}`;
            mac[crossSigningKeyId] = calculateMAC(olmSAS, method)(
@@ -484,14 +496,14 @@ export class SAS extends Base {
            keyList.sort().join(","),
            baseInfo + "KEY_IDS",
        );
-        return this._send("m.key.verification.mac", { mac, keys });
+        return this.send("m.key.verification.mac", { mac, keys });
    }

-    async _checkMAC(olmSAS, content, method) {
+    private async checkMAC(olmSAS: OlmSAS, content: IContent, method: string): Promise<void> {
        const baseInfo = "MATRIX_KEY_VERIFICATION_MAC"
              + this.userId + this.deviceId
-              + this._baseApis.getUserId() + this._baseApis.deviceId
-              + this._channel.transactionId;
+              + this.baseApis.getUserId() + this.baseApis.deviceId
+              + this.channel.transactionId;

        if (content.keys !== calculateMAC(olmSAS, method)(
            Object.keys(content.mac).sort().join(","),
@@ -500,7 +512,7 @@ export class SAS extends Base {
            throw newKeyMismatchError();
        }

-        await this._verifyKeys(this.userId, content.mac, (keyId, device, keyInfo) => {
+        await this.verifyKeys(this.userId, content.mac, (keyId, device, keyInfo) => {
            if (keyInfo !== calculateMAC(olmSAS, method)(
                device.keys[keyId],
                baseInfo + keyId,
@@ -0,0 +1,33 @@
+/*
+Copyright 2021 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 { MatrixEvent } from "../../../models/event";
+import { VerificationRequest } from "./VerificationRequest";
+
+export interface IVerificationChannel {
+    request?: VerificationRequest;
+    readonly userId: string;
+    readonly roomId?: string;
+    readonly deviceId?: string;
+    readonly transactionId: string;
+    readonly receiveStartFromOtherDevices?: boolean;
+    getTimestamp(event: MatrixEvent): number;
+    send(type: string, uncompletedContent: Record<string, any>): Promise<void>;
+    completeContent(type: string, content: Record<string, any>): Record<string, any>;
+    sendCompleted(type: string, content: Record<string, any>): Promise<void>;
+    completedContentFromEvent(event: MatrixEvent): Record<string, any>;
+    canCreateRequest(type: string): boolean;
+}
@@ -22,8 +22,12 @@ import {
    START_TYPE,
 } from "./VerificationRequest";
 import { logger } from '../../../logger';
+import { IVerificationChannel } from "./Channel";
+import { EventType } from "../../../@types/event";
+import { MatrixClient } from "../../../client";
+import { MatrixEvent } from "../../../models/event";

-const MESSAGE_TYPE = "m.room.message";
+const MESSAGE_TYPE = EventType.RoomMessage;
 const M_REFERENCE = "m.reference";
 const M_RELATES_TO = "m.relates_to";

@@ -31,36 +35,34 @@ const M_RELATES_TO = "m.relates_to";
 * A key verification channel that sends verification events in the timeline of a room.
 * Uses the event id of the initial m.key.verification.request event as a transaction id.
 */
-export class InRoomChannel {
+export class InRoomChannel implements IVerificationChannel {
+    private requestEventId = null;
+
    /**
     * @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.
     */
-    constructor(client, roomId, userId = null) {
-        this._client = client;
-        this._roomId = roomId;
-        this.userId = userId;
-        this._requestEventId = null;
+    constructor(
+        private readonly client: MatrixClient,
+        public readonly roomId: string,
+        public userId: string = null,
+    ) {
    }

-    get receiveStartFromOtherDevices() {
+    public get receiveStartFromOtherDevices(): boolean {
        return true;
    }

-    get roomId() {
-        return this._roomId;
-    }
-
    /** The transaction id generated/used by this verification channel */
-    get transactionId() {
-        return this._requestEventId;
+    public get transactionId(): string {
+        return this.requestEventId;
    }

-    static getOtherPartyUserId(event, client) {
+    public static getOtherPartyUserId(event: MatrixEvent, client: MatrixClient): string {
        const type = InRoomChannel.getEventType(event);
        if (type !== REQUEST_TYPE) {
-           return;
+            return;
        }
        const ownUserId = client.getUserId();
        const sender = event.getSender();
@@ -78,25 +80,29 @@ export class InRoomChannel {
     * @param {MatrixEvent} event the event to get the timestamp of
     * @return {number} the timestamp when the event was sent
     */
-    getTimestamp(event) {
+    public getTimestamp(event: MatrixEvent): number {
        return event.getTs();
    }

    /**
     * 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 {bool} boolean flag
+     * @returns {boolean} boolean flag
     */
-    static canCreateRequest(type) {
+    public static canCreateRequest(type: string): boolean {
        return type === REQUEST_TYPE;
    }

+    public canCreateRequest(type: string): boolean {
+        return InRoomChannel.canCreateRequest(type);
+    }
+
    /**
     * Extract the transaction id used by a given key verification event, if any
     * @param {MatrixEvent} event the event
     * @returns {string} the transaction id
     */
-    static getTransactionId(event) {
+    public static getTransactionId(event: MatrixEvent): string {
        if (InRoomChannel.getEventType(event) === REQUEST_TYPE) {
            return event.getId();
        } else {
@@ -114,9 +120,9 @@ export class InRoomChannel {
     * `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 {bool} whether the event is valid and should be passed to handleEvent
+     * @returns {boolean} whether the event is valid and should be passed to handleEvent
     */
-    static validateEvent(event, client) {
+    public static validateEvent(event: MatrixEvent, client: MatrixClient): boolean {
        const txnId = InRoomChannel.getTransactionId(event);
        if (typeof txnId !== "string" || txnId.length === 0) {
            return false;
@@ -152,7 +158,7 @@ export class InRoomChannel {
     * @param {MatrixEvent} event the event to get the type of
     * @returns {string} the "symbolic" event type
     */
-    static getEventType(event) {
+    public static getEventType(event: MatrixEvent): string {
        const type = event.getType();
        if (type === MESSAGE_TYPE) {
            const content = event.getContent();
@@ -174,10 +180,10 @@ export class InRoomChannel {
     * 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 {bool} isLiveEvent whether this is an even received through sync or not
-     * @returns {Promise} a promise that resolves when any requests as an anwser to the passed-in event are sent.
+     * @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.
     */
-    async handleEvent(event, request, isLiveEvent) {
+    public async handleEvent(event: MatrixEvent, request: VerificationRequest, isLiveEvent = false): Promise<void> {
        // prevent processing the same event multiple times, as under
        // some circumstances Room.timeline can get emitted twice for the same event
        if (request.hasEventId(event.getId())) {
@@ -187,18 +193,18 @@ export class InRoomChannel {
        // do validations that need state (roomId, userId),
        // ignore if invalid

-        if (event.getRoomId() !== this._roomId) {
+        if (event.getRoomId() !== this.roomId) {
            return;
        }
        // set userId if not set already
        if (this.userId === null) {
-            const userId = InRoomChannel.getOtherPartyUserId(event, this._client);
+            const userId = InRoomChannel.getOtherPartyUserId(event, this.client);
            if (userId) {
                this.userId = userId;
            }
        }
        // ignore events not sent by us or the other party
-        const ownUserId = this._client.getUserId();
+        const ownUserId = this.client.getUserId();
        const sender = event.getSender();
        if (this.userId !== null) {
            if (sender !== ownUserId && sender !== this.userId) {
@@ -207,12 +213,12 @@ export class InRoomChannel {
                return;
            }
        }
-        if (this._requestEventId === null) {
-            this._requestEventId = InRoomChannel.getTransactionId(event);
+        if (this.requestEventId === null) {
+            this.requestEventId = InRoomChannel.getTransactionId(event);
        }

        const isRemoteEcho = !!event.getUnsigned().transaction_id;
-        const isSentByUs = event.getSender() === this._client.getUserId();
+        const isSentByUs = event.getSender() === this.client.getUserId();

        return await request.handleEvent(
            type, event, isLiveEvent, isRemoteEcho, isSentByUs);
@@ -226,13 +232,14 @@ export class InRoomChannel {
     * @param {MatrixEvent} event the received event
     * @returns {Object} the content object with the relation added again
     */
-    completedContentFromEvent(event) {
+    public completedContentFromEvent(event: MatrixEvent): Record<string, any> {
        // ensure m.related_to is included in e2ee rooms
        // as the field is excluded from encryption
        const content = Object.assign({}, event.getContent());
        content[M_RELATES_TO] = event.getRelation();
        return content;
    }
+
    /**
     * Add all the fields to content needed for sending it over this channel.
     * This is public so verification methods (SAS uses this) can get the exact
@@ -242,15 +249,15 @@ export class InRoomChannel {
     * @param {object} content the (incomplete) content
     * @returns {object} the complete content, as it will be sent.
     */
-    completeContent(type, content) {
+    public completeContent(type: string, content: Record<string, any>): Record<string, any> {
        content = Object.assign({}, content);
        if (type === REQUEST_TYPE || type === READY_TYPE || type === START_TYPE) {
-            content.from_device = this._client.getDeviceId();
+            content.from_device = this.client.getDeviceId();
        }
        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.",
@@ -274,7 +281,7 @@ export class InRoomChannel {
     * @param {object} uncompletedContent the (incomplete) content
     * @returns {Promise} the promise of the request
     */
-    send(type, uncompletedContent) {
+    public send(type: string, uncompletedContent: Record<string, any>): Promise<void> {
        const content = this.completeContent(type, uncompletedContent);
        return this.sendCompleted(type, content);
    }
@@ -285,74 +292,68 @@ export class InRoomChannel {
     * @param {object} content
     * @returns {Promise} the promise of the request
     */
-    async sendCompleted(type, content) {
+    public async sendCompleted(type: string, content: Record<string, any>): Promise<void> {
        let sendType = type;
        if (type === REQUEST_TYPE) {
            sendType = MESSAGE_TYPE;
        }
-        const response = await this._client.sendEvent(this._roomId, sendType, content);
+        const response = await this.client.sendEvent(this.roomId, sendType, content);
        if (type === REQUEST_TYPE) {
-            this._requestEventId = response.event_id;
+            this.requestEventId = response.event_id;
        }
    }
 }

 export class InRoomRequests {
-    constructor() {
-        this._requestsByRoomId = new Map();
-    }
+    private requestsByRoomId = new Map<string, Map<string, VerificationRequest>>();

-    getRequest(event) {
+    public getRequest(event: MatrixEvent): VerificationRequest {
        const roomId = event.getRoomId();
        const txnId = InRoomChannel.getTransactionId(event);
-        return this._getRequestByTxnId(roomId, txnId);
+        return this.getRequestByTxnId(roomId, txnId);
    }

-    getRequestByChannel(channel) {
-        return this._getRequestByTxnId(channel.roomId, channel.transactionId);
+    public getRequestByChannel(channel: InRoomChannel): VerificationRequest {
+        return this.getRequestByTxnId(channel.roomId, channel.transactionId);
    }

-    _getRequestByTxnId(roomId, txnId) {
-        const requestsByTxnId = this._requestsByRoomId.get(roomId);
+    private getRequestByTxnId(roomId: string, txnId: string): VerificationRequest {
+        const requestsByTxnId = this.requestsByRoomId.get(roomId);
        if (requestsByTxnId) {
            return requestsByTxnId.get(txnId);
        }
    }

-    setRequest(event, request) {
-        this._setRequest(
-            event.getRoomId(),
-            InRoomChannel.getTransactionId(event),
-            request,
-        );
+    public setRequest(event: MatrixEvent, request: VerificationRequest): void {
+        this.doSetRequest(event.getRoomId(), InRoomChannel.getTransactionId(event), request);
    }

-    setRequestByChannel(channel, request) {
-        this._setRequest(channel.roomId, channel.transactionId, request);
+    public setRequestByChannel(channel: InRoomChannel, request: VerificationRequest): void {
+        this.doSetRequest(channel.roomId, channel.transactionId, request);
    }

-    _setRequest(roomId, txnId, request) {
-        let requestsByTxnId = this._requestsByRoomId.get(roomId);
+    private doSetRequest(roomId: string, txnId: string, request: VerificationRequest): void {
+        let requestsByTxnId = this.requestsByRoomId.get(roomId);
        if (!requestsByTxnId) {
            requestsByTxnId = new Map();
-            this._requestsByRoomId.set(roomId, requestsByTxnId);
+            this.requestsByRoomId.set(roomId, requestsByTxnId);
        }
        requestsByTxnId.set(txnId, request);
    }

-    removeRequest(event) {
+    public removeRequest(event: MatrixEvent): void {
        const roomId = event.getRoomId();
-        const requestsByTxnId = this._requestsByRoomId.get(roomId);
+        const requestsByTxnId = this.requestsByRoomId.get(roomId);
        if (requestsByTxnId) {
            requestsByTxnId.delete(InRoomChannel.getTransactionId(event));
            if (requestsByTxnId.size === 0) {
-                this._requestsByRoomId.delete(roomId);
+                this.requestsByRoomId.delete(roomId);
            }
        }
    }

-    findRequestInProgress(roomId) {
-        const requestsByTxnId = this._requestsByRoomId.get(roomId);
+    public findRequestInProgress(roomId: string): VerificationRequest {
+        const requestsByTxnId = this.requestsByRoomId.get(roomId);
        if (requestsByTxnId) {
            for (const request of requestsByTxnId.values()) {
                if (request.pending) {
@@ -28,26 +28,31 @@ import {
 } from "./VerificationRequest";
 import { errorFromEvent, newUnexpectedMessageError } from "../Error";
 import { MatrixEvent } from "../../../models/event";
+import { IVerificationChannel } from "./Channel";
+import { MatrixClient } from "../../../client";
+
+type Request = VerificationRequest<ToDeviceChannel>;

 /**
 * A key verification channel that sends verification events over to_device messages.
 * Generates its own transaction ids.
 */
-export class ToDeviceChannel {
-    // userId and devices of user we're about to verify
-    constructor(client, userId, devices, transactionId = null, deviceId = null) {
-        this._client = client;
-        this.userId = userId;
-        this._devices = devices;
-        this.transactionId = transactionId;
-        this._deviceId = deviceId;
-    }
+export class ToDeviceChannel implements IVerificationChannel {
+    public request?: VerificationRequest;

-    isToDevices(devices) {
-        if (devices.length === this._devices.length) {
+    // userId and devices of user we're about to verify
+    constructor(
+        private readonly client: MatrixClient,
+        public readonly userId: string,
+        private readonly devices: string[],
+        public transactionId: string = null,
+        public deviceId: string = null,
+    ) {}
+
+    public isToDevices(devices: string[]): boolean {
+        if (devices.length === this.devices.length) {
            for (const device of devices) {
-                const d = this._devices.find(d => d.deviceId === device.deviceId);
-                if (!d) {
+                if (!this.devices.includes(device)) {
                    return false;
                }
            }
@@ -57,11 +62,7 @@ export class ToDeviceChannel {
        }
    }

-    get deviceId() {
-        return this._deviceId;
-    }
-
-    static getEventType(event) {
+    public static getEventType(event: MatrixEvent): string {
        return event.getType();
    }

@@ -70,7 +71,7 @@ export class ToDeviceChannel {
     * @param {MatrixEvent} event the event
     * @returns {string} the transaction id
     */
-    static getTransactionId(event) {
+    public static getTransactionId(event: MatrixEvent): string {
        const content = event.getContent();
        return content && content.transaction_id;
    }
@@ -78,12 +79,16 @@ export class ToDeviceChannel {
    /**
     * 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 {bool} boolean flag
+     * @returns {boolean} boolean flag
     */
-    static canCreateRequest(type) {
+    public static canCreateRequest(type: string): boolean {
        return type === REQUEST_TYPE || type === START_TYPE;
    }

+    public canCreateRequest(type: string): boolean {
+        return ToDeviceChannel.canCreateRequest(type);
+    }
+
    /**
     * Checks whether this event is a well-formed key verification event.
     * This only does checks that don't rely on the current state of a potentially already channel
@@ -91,9 +96,9 @@ export class ToDeviceChannel {
     * `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 {bool} whether the event is valid and should be passed to handleEvent
+     * @returns {boolean} whether the event is valid and should be passed to handleEvent
     */
-    static validateEvent(event, client) {
+    public static validateEvent(event: MatrixEvent, client: MatrixClient): boolean {
        if (event.isCancelled()) {
            logger.warn("Ignoring flagged verification request from "
                 + event.getSender());
@@ -134,7 +139,7 @@ export class ToDeviceChannel {
     * @param {MatrixEvent} event the event to get the timestamp of
     * @return {number} the timestamp when the event was sent
     */
-    getTimestamp(event) {
+    public getTimestamp(event: MatrixEvent): number {
        const content = event.getContent();
        return content && content.timestamp;
    }
@@ -143,10 +148,10 @@ export class ToDeviceChannel {
     * 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 {bool} isLiveEvent whether this is an even received through sync or not
-     * @returns {Promise} a promise that resolves when any requests as an anwser to the passed-in event are sent.
+     * @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.
     */
-    async handleEvent(event, request, isLiveEvent) {
+    public async handleEvent(event: MatrixEvent, request: Request, isLiveEvent = false): Promise<void> {
        const type = event.getType();
        const content = event.getContent();
        if (type === REQUEST_TYPE || type === READY_TYPE || type === START_TYPE) {
@@ -155,17 +160,16 @@ export class ToDeviceChannel {
            }
            const deviceId = content.from_device;
            // adopt deviceId if not set before and valid
-            if (!this._deviceId && this._devices.includes(deviceId)) {
-                this._deviceId = deviceId;
+            if (!this.deviceId && this.devices.includes(deviceId)) {
+                this.deviceId = deviceId;
            }
-            // if no device id or different from addopted one, cancel with sender
-            if (!this._deviceId || this._deviceId !== deviceId) {
+            // if no device id or different from adopted one, cancel with sender
+            if (!this.deviceId || this.deviceId !== deviceId) {
                // also check that message came from the device we sent the request to earlier on
                // and do send a cancel message to that device
                // (but don't cancel the request for the device we should be talking to)
-                const cancelContent =
-                    this.completeContent(errorFromEvent(newUnexpectedMessageError()));
-                return this._sendToDevices(CANCEL_TYPE, cancelContent, [deviceId]);
+                const cancelContent = this.completeContent(CANCEL_TYPE, errorFromEvent(newUnexpectedMessageError()));
+                return this.sendToDevices(CANCEL_TYPE, cancelContent, [deviceId]);
            }
        }
        const wasStarted = request.phase === PHASE_STARTED ||
@@ -178,16 +182,16 @@ export class ToDeviceChannel {

        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(),
+        if (isAcceptingEvent && !wasStarted && isStarted && this.deviceId) {
+            const nonChosenDevices = this.devices.filter(
+                d => d !== this.deviceId && d !== this.client.getDeviceId(),
            );
            if (nonChosenDevices.length) {
-                const message = this.completeContent({
+                const message = this.completeContent(CANCEL_TYPE, {
                    code: "m.accepted",
                    reason: "Verification request accepted by another device",
                });
-                await this._sendToDevices(CANCEL_TYPE, message, nonChosenDevices);
+                await this.sendToDevices(CANCEL_TYPE, message, nonChosenDevices);
            }
        }
    }
@@ -197,7 +201,7 @@ export class ToDeviceChannel {
     * @param {MatrixEvent} event the received event
     * @returns {Object} the content object
     */
-    completedContentFromEvent(event) {
+    public completedContentFromEvent(event: MatrixEvent): Record<string, any> {
        return event.getContent();
    }

@@ -210,14 +214,14 @@ export class ToDeviceChannel {
     * @param {object} content the (incomplete) content
     * @returns {object} the complete content, as it will be sent.
     */
-    completeContent(type, content) {
+    public completeContent(type: string, content: Record<string, any>): Record<string, any> {
        // make a copy
        content = Object.assign({}, content);
        if (this.transactionId) {
            content.transaction_id = this.transactionId;
        }
        if (type === REQUEST_TYPE || type === READY_TYPE || type === START_TYPE) {
-            content.from_device = this._client.getDeviceId();
+            content.from_device = this.client.getDeviceId();
        }
        if (type === REQUEST_TYPE) {
            content.timestamp = Date.now();
@@ -231,7 +235,7 @@ export class ToDeviceChannel {
     * @param {object} uncompletedContent the (incomplete) content
     * @returns {Promise} the promise of the request
     */
-    send(type, uncompletedContent = {}) {
+    public send(type: string, uncompletedContent: Record<string, any> = {}): Promise<void> {
        // create transaction id when sending request
        if ((type === REQUEST_TYPE || type === START_TYPE) && !this.transactionId) {
            this.transactionId = ToDeviceChannel.makeTransactionId();
@@ -246,21 +250,21 @@ export class ToDeviceChannel {
     * @param {object} content
     * @returns {Promise} the promise of the request
     */
-    async sendCompleted(type, content) {
+    public async sendCompleted(type: string, content: Record<string, any>): Promise<void> {
        let result;
-        if (type === REQUEST_TYPE || (type === CANCEL_TYPE && !this.__deviceId)) {
-            result = await this._sendToDevices(type, content, this._devices);
+        if (type === REQUEST_TYPE || (type === CANCEL_TYPE && !this.deviceId)) {
+            result = await this.sendToDevices(type, content, this.devices);
        } else {
-            result = await this._sendToDevices(type, content, [this._deviceId]);
+            result = await this.sendToDevices(type, content, [this.deviceId]);
        }
        // the VerificationRequest state machine requires remote echos of the event
        // the client sends itself, so we fake this for to_device messages
        const remoteEchoEvent = new MatrixEvent({
-            sender: this._client.getUserId(),
+            sender: this.client.getUserId(),
            content,
            type,
        });
-        await this._request.handleEvent(
+        await this.request.handleEvent(
            type,
            remoteEchoEvent,
            /*isLiveEvent=*/true,
@@ -270,16 +274,14 @@ export class ToDeviceChannel {
        return result;
    }

-    _sendToDevices(type, content, devices) {
+    private async sendToDevices(type: string, content: Record<string, any>, devices: string[]): Promise<void> {
        if (devices.length) {
            const msgMap = {};
            for (const deviceId of devices) {
                msgMap[deviceId] = content;
            }

-            return this._client.sendToDevice(type, { [this.userId]: msgMap });
-        } else {
-            return Promise.resolve();
+            await this.client.sendToDevice(type, { [this.userId]: msgMap });
        }
    }

@@ -287,68 +289,62 @@ export class ToDeviceChannel {
     * Allow Crypto module to create and know the transaction id before the .start event gets sent.
     * @returns {string} the transaction id
     */
-    static makeTransactionId() {
+    public static makeTransactionId(): string {
        return randomString(32);
    }
 }

 export class ToDeviceRequests {
-    constructor() {
-        this._requestsByUserId = new Map();
-    }
+    private requestsByUserId = new Map<string, Map<string, Request>>();

-    getRequest(event) {
+    public getRequest(event: MatrixEvent): Request {
        return this.getRequestBySenderAndTxnId(
            event.getSender(),
            ToDeviceChannel.getTransactionId(event),
        );
    }

-    getRequestByChannel(channel) {
+    public getRequestByChannel(channel: ToDeviceChannel): Request {
        return this.getRequestBySenderAndTxnId(channel.userId, channel.transactionId);
    }

-    getRequestBySenderAndTxnId(sender, txnId) {
-        const requestsByTxnId = this._requestsByUserId.get(sender);
+    public getRequestBySenderAndTxnId(sender: string, txnId: string): Request {
+        const requestsByTxnId = this.requestsByUserId.get(sender);
        if (requestsByTxnId) {
            return requestsByTxnId.get(txnId);
        }
    }

-    setRequest(event, request) {
-        this.setRequestBySenderAndTxnId(
-            event.getSender(),
-            ToDeviceChannel.getTransactionId(event),
-            request,
-        );
+    public setRequest(event: MatrixEvent, request: Request): void {
+        this.setRequestBySenderAndTxnId(event.getSender(), ToDeviceChannel.getTransactionId(event), request);
    }

-    setRequestByChannel(channel, request) {
+    public setRequestByChannel(channel: ToDeviceChannel, request: Request): void {
        this.setRequestBySenderAndTxnId(channel.userId, channel.transactionId, request);
    }

-    setRequestBySenderAndTxnId(sender, txnId, request) {
-        let requestsByTxnId = this._requestsByUserId.get(sender);
+    public setRequestBySenderAndTxnId(sender: string, txnId: string, request: Request): void {
+        let requestsByTxnId = this.requestsByUserId.get(sender);
        if (!requestsByTxnId) {
            requestsByTxnId = new Map();
-            this._requestsByUserId.set(sender, requestsByTxnId);
+            this.requestsByUserId.set(sender, requestsByTxnId);
        }
        requestsByTxnId.set(txnId, request);
    }

-    removeRequest(event) {
+    public removeRequest(event: MatrixEvent): void {
        const userId = event.getSender();
-        const requestsByTxnId = this._requestsByUserId.get(userId);
+        const requestsByTxnId = this.requestsByUserId.get(userId);
        if (requestsByTxnId) {
            requestsByTxnId.delete(ToDeviceChannel.getTransactionId(event));
            if (requestsByTxnId.size === 0) {
-                this._requestsByUserId.delete(userId);
+                this.requestsByUserId.delete(userId);
            }
        }
    }

-    findRequestInProgress(userId, devices) {
-        const requestsByTxnId = this._requestsByUserId.get(userId);
+    public findRequestInProgress(userId: string, devices: string[]): Request {
+        const requestsByTxnId = this.requestsByUserId.get(userId);
        if (requestsByTxnId) {
            for (const request of requestsByTxnId.values()) {
                if (request.pending && request.channel.isToDevices(devices)) {
@@ -358,8 +354,8 @@ export class ToDeviceRequests {
        }
    }

-    getRequestsInProgress(userId) {
-        const requestsByTxnId = this._requestsByUserId.get(userId);
+    public getRequestsInProgress(userId: string): Request[] {
+        const requestsByTxnId = this.requestsByUserId.get(userId);
        if (requestsByTxnId) {
            return Array.from(requestsByTxnId.values()).filter(r => r.pending);
        }
@@ -1,6 +1,5 @@
 /*
-Copyright 2018 New Vector Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
+Copyright 2018 - 2021 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.
@@ -24,6 +23,11 @@ import {
    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 { VerificationBase } from "../Base";
+import { VerificationMethod } from "../../index";

 // How long after the event's timestamp that the request times out
 const TIMEOUT_FROM_EVENT_TS = 10 * 60 * 1000; // 10 minutes
@@ -44,12 +48,32 @@ export const CANCEL_TYPE = EVENT_PREFIX + "cancel";
 export const DONE_TYPE = EVENT_PREFIX + "done";
 export const READY_TYPE = EVENT_PREFIX + "ready";

-export const PHASE_UNSENT = 1;
-export const PHASE_REQUESTED = 2;
-export const PHASE_READY = 3;
-export const PHASE_STARTED = 4;
-export const PHASE_CANCELLED = 5;
-export const PHASE_DONE = 6;
+export enum Phase {
+    Unsent = 1,
+    Requested,
+    Ready,
+    Started,
+    Cancelled,
+    Done,
+}
+
+// Legacy export fields
+export const PHASE_UNSENT = Phase.Unsent;
+export const PHASE_REQUESTED = Phase.Requested;
+export const PHASE_READY = Phase.Ready;
+export const PHASE_STARTED = Phase.Started;
+export const PHASE_CANCELLED = Phase.Cancelled;
+export const PHASE_DONE = Phase.Done;
+
+interface ITargetDevice {
+    userId?: string;
+    deviceId?: string;
+}
+
+interface ITransition {
+    phase: Phase;
+    event?: MatrixEvent;
+}

 /**
 * State machine for verification requests.
@@ -57,32 +81,38 @@ export const PHASE_DONE = 6;
 * 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 extends EventEmitter {
-    constructor(channel, verificationMethods, client) {
-        super();
-        this.channel = channel;
-        this.channel._request = this;
-        this._verificationMethods = verificationMethods;
-        this._client = client;
-        this._commonMethods = [];
-        this._setPhase(PHASE_UNSENT, false);
-        this._eventsByUs = new Map();
-        this._eventsByThem = new Map();
-        this._observeOnly = false;
-        this._timeoutTimer = null;
-        this._accepting = false;
-        this._declining = false;
-        this._verifierHasFinished = false;
-        this._cancelled = false;
-        this._chosenMethod = null;
-        // we keep a copy of the QR Code data (including other user master key) around
-        // for QR reciprocate verification, to protect against
-        // cross-signing identity reset between the .ready and .start event
-        // and signing the wrong key after .start
-        this._qrCodeData = null;
+export class VerificationRequest<C extends IVerificationChannel = IVerificationChannel> extends EventEmitter {
+    private eventsByUs = new Map<string, MatrixEvent>();
+    private eventsByThem = new Map<string, MatrixEvent>();
+    private _observeOnly = false;
+    private timeoutTimer: number = null;
+    private _accepting = false;
+    private _declining = false;
+    private verifierHasFinished = false;
+    private _cancelled = false;
+    private _chosenMethod: VerificationMethod = null;
+    // we keep a copy of the QR Code data (including other user master key) around
+    // for QR reciprocate verification, to protect against
+    // cross-signing identity reset between the .ready and .start event
+    // and signing the wrong key after .start
+    private _qrCodeData: QRCodeData = null;

-        // The timestamp when we received the request event from the other side
-        this._requestReceivedAt = null;
+    // The timestamp when we received the request event from the other side
+    private requestReceivedAt: number = null;
+
+    private commonMethods: VerificationMethod[] = [];
+    private _phase: Phase;
+    private _cancellingUserId: string;
+    private _verifier: VerificationBase;
+
+    constructor(
+        public readonly channel: C,
+        private readonly verificationMethods: Map<VerificationMethod, typeof VerificationBase>,
+        private readonly client: MatrixClient,
+    ) {
+        super();
+        this.channel.request = this;
+        this.setPhase(PHASE_UNSENT, false);
    }

    /**
@@ -91,9 +121,9 @@ export class VerificationRequest extends EventEmitter {
     * @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 {bool} whether the event is valid and should be passed to handleEvent
+     * @returns {boolean} whether the event is valid and should be passed to handleEvent
     */
-    static validateEvent(type, event, client) {
+    public static validateEvent(type: string, event: MatrixEvent, client: MatrixClient): boolean {
        const content = event.getContent();

        if (!type || !type.startsWith(EVENT_PREFIX)) {
@@ -128,53 +158,53 @@ export class VerificationRequest extends EventEmitter {
        return true;
    }

-    get invalid() {
+    public get invalid(): boolean {
        return this.phase === PHASE_UNSENT;
    }

    /** returns whether the phase is PHASE_REQUESTED */
-    get requested() {
+    public get requested(): boolean {
        return this.phase === PHASE_REQUESTED;
    }

    /** returns whether the phase is PHASE_CANCELLED */
-    get cancelled() {
+    public get cancelled(): boolean {
        return this.phase === PHASE_CANCELLED;
    }

    /** returns whether the phase is PHASE_READY */
-    get ready() {
+    public get ready(): boolean {
        return this.phase === PHASE_READY;
    }

    /** returns whether the phase is PHASE_STARTED */
-    get started() {
+    public get started(): boolean {
        return this.phase === PHASE_STARTED;
    }

    /** returns whether the phase is PHASE_DONE */
-    get done() {
+    public get done(): boolean {
        return this.phase === PHASE_DONE;
    }

    /** once the phase is PHASE_STARTED (and !initiatedByMe) or PHASE_READY: common methods supported by both sides */
-    get methods() {
-        return this._commonMethods;
+    public get methods(): VerificationMethod[] {
+        return this.commonMethods;
    }

    /** the method picked in the .start event */
-    get chosenMethod() {
+    public get chosenMethod(): VerificationMethod {
        return this._chosenMethod;
    }

-    calculateEventTimeout(event) {
+    public calculateEventTimeout(event: MatrixEvent): number {
        let effectiveExpiresAt = this.channel.getTimestamp(event)
            + TIMEOUT_FROM_EVENT_TS;

-        if (this._requestReceivedAt && !this.initiatedByMe &&
+        if (this.requestReceivedAt && !this.initiatedByMe &&
            this.phase <= PHASE_REQUESTED
        ) {
-            const expiresAtByReceipt = this._requestReceivedAt
+            const expiresAtByReceipt = this.requestReceivedAt
                + TIMEOUT_FROM_EVENT_RECEIPT;
            effectiveExpiresAt = Math.min(effectiveExpiresAt, expiresAtByReceipt);
        }
@@ -183,8 +213,8 @@ export class VerificationRequest extends EventEmitter {
    }

    /** The current remaining amount of ms before the request should be automatically cancelled */
-    get timeout() {
-        const requestEvent = this._getEventByEither(REQUEST_TYPE);
+    public get timeout(): number {
+        const requestEvent = this.getEventByEither(REQUEST_TYPE);
        if (requestEvent) {
            return this.calculateEventTimeout(requestEvent);
        }
@@ -195,41 +225,41 @@ export class VerificationRequest extends EventEmitter {
     * The key verification request event.
     * @returns {MatrixEvent} The request event, or falsey if not found.
     */
-    get requestEvent() {
-        return this._getEventByEither(REQUEST_TYPE);
+    public get requestEvent(): MatrixEvent {
+        return this.getEventByEither(REQUEST_TYPE);
    }

    /** current phase of the request. Some properties might only be defined in a current phase. */
-    get phase() {
+    public get phase(): Phase {
        return this._phase;
    }

    /** The verifier to do the actual verification, once the method has been established. Only defined when the `phase` is PHASE_STARTED. */
-    get verifier() {
+    public get verifier(): VerificationBase {
        return this._verifier;
    }

-    get canAccept() {
+    public get canAccept(): boolean {
        return this.phase < PHASE_READY && !this._accepting && !this._declining;
    }

-    get accepting() {
+    public get accepting(): boolean {
        return this._accepting;
    }

-    get declining() {
+    public get declining(): boolean {
        return this._declining;
    }

    /** whether this request has sent it's initial event and needs more events to complete */
-    get pending() {
+    public get pending(): boolean {
        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 */
-    get qrCodeData() {
+    public get qrCodeData(): QRCodeData {
        return this._qrCodeData;
    }

@@ -239,19 +269,19 @@ export class VerificationRequest extends EventEmitter {
     *  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 {bool} whether or not the other party said the supported the method */
-    otherPartySupportsMethod(method, force = false) {
+     *  @return {boolean} 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;
        }
-        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
            // chosen method, so return true for that.
            if (this.started && this.initiatedByMe) {
-                const myStartEvent = this._eventsByUs.get(START_TYPE);
+                const myStartEvent = this.eventsByUs.get(START_TYPE);
                const content = myStartEvent && myStartEvent.getContent();
                const myStartMethod = content && content.method;
                return method == myStartMethod;
@@ -274,22 +304,22 @@ export class VerificationRequest extends EventEmitter {
     * For InRoomChannel, this is who sent the .request event.
     * For ToDeviceChannel, this is who sent the .start event
     */
-    get initiatedByMe() {
+    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;
        }
-        const hasMyRequest = this._eventsByUs.has(REQUEST_TYPE);
-        const hasTheirRequest = this._eventsByThem.has(REQUEST_TYPE);
+        const hasMyRequest = this.eventsByUs.has(REQUEST_TYPE);
+        const hasTheirRequest = this.eventsByThem.has(REQUEST_TYPE);
        if (hasMyRequest && !hasTheirRequest) {
            return true;
        }
        if (!hasMyRequest && hasTheirRequest) {
            return false;
        }
-        const hasMyStart = this._eventsByUs.has(START_TYPE);
-        const hasTheirStart = this._eventsByThem.has(START_TYPE);
+        const hasMyStart = this.eventsByUs.has(START_TYPE);
+        const hasTheirStart = this.eventsByThem.has(START_TYPE);
        if (hasMyStart && !hasTheirStart) {
            return true;
        }
@@ -297,39 +327,39 @@ export class VerificationRequest extends EventEmitter {
    }

    /** The id of the user that initiated the request */
-    get requestingUserId() {
+    public get requestingUserId(): string {
        if (this.initiatedByMe) {
-            return this._client.getUserId();
+            return this.client.getUserId();
        } else {
            return this.otherUserId;
        }
    }

    /** The id of the user that (will) receive(d) the request */
-    get receivingUserId() {
+    public get receivingUserId(): string {
        if (this.initiatedByMe) {
            return this.otherUserId;
        } else {
-            return this._client.getUserId();
+            return this.client.getUserId();
        }
    }

    /** The user id of the other party in this request */
-    get otherUserId() {
+    public get otherUserId(): string {
        return this.channel.userId;
    }

-    get isSelfVerification() {
-        return this._client.getUserId() === this.otherUserId;
+    public get isSelfVerification(): boolean {
+        return this.client.getUserId() === this.otherUserId;
    }

    /**
     * The id of the user that cancelled the request,
     * only defined when phase is PHASE_CANCELLED
     */
-    get cancellingUserId() {
-        const myCancel = this._eventsByUs.get(CANCEL_TYPE);
-        const theirCancel = this._eventsByThem.get(CANCEL_TYPE);
+    public get cancellingUserId(): string {
+        const myCancel = this.eventsByUs.get(CANCEL_TYPE);
+        const theirCancel = this.eventsByThem.get(CANCEL_TYPE);

        if (myCancel && (!theirCancel || myCancel.getId() < theirCancel.getId())) {
            return myCancel.getSender();
@@ -343,12 +373,12 @@ export class VerificationRequest extends EventEmitter {
    /**
     * The cancellation code e.g m.user which is responsible for cancelling this verification
     */
-    get cancellationCode() {
-        const ev = this._getEventByEither(CANCEL_TYPE);
+    public get cancellationCode(): string {
+        const ev = this.getEventByEither(CANCEL_TYPE);
        return ev ? ev.getContent().code : null;
    }

-    get observeOnly() {
+    public get observeOnly(): boolean {
        return this._observeOnly;
    }

@@ -359,11 +389,11 @@ export class VerificationRequest extends EventEmitter {
     * verification to when no specific device is specified.
     * @returns {{userId: *, deviceId: *}} The device information
     */
-    get targetDevice() {
+    public get targetDevice(): ITargetDevice {
        const theirFirstEvent =
-            this._eventsByThem.get(REQUEST_TYPE) ||
-            this._eventsByThem.get(READY_TYPE) ||
-            this._eventsByThem.get(START_TYPE);
+            this.eventsByThem.get(REQUEST_TYPE) ||
+            this.eventsByThem.get(READY_TYPE) ||
+            this.eventsByThem.get(START_TYPE);
        const theirFirstContent = theirFirstEvent.getContent();
        const fromDevice = theirFirstContent.from_device;
        return {
@@ -379,21 +409,20 @@ export class VerificationRequest extends EventEmitter {
     * @param {string?} targetDevice.deviceId the id of the device to direct this request to
     * @returns {VerifierBase} the verifier of the given method
     */
-    beginKeyVerification(method, targetDevice = null) {
+    public beginKeyVerification(method: VerificationMethod, targetDevice: ITargetDevice = null): VerificationBase {
        // need to allow also when unsent in case of to_device
        if (!this.observeOnly && !this._verifier) {
            const validStartPhase =
                this.phase === PHASE_REQUESTED ||
                this.phase === PHASE_READY ||
-                (this.phase === PHASE_UNSENT &&
-                    this.channel.constructor.canCreateRequest(START_TYPE));
+                (this.phase === PHASE_UNSENT && this.channel.canCreateRequest(START_TYPE));
            if (validStartPhase) {
                // when called on a request that was initiated with .request event
                // check the method is supported by both sides
-                if (this._commonMethods.length && !this._commonMethods.includes(method)) {
+                if (this.commonMethods.length && !this.commonMethods.includes(method)) {
                    throw newUnknownMethodError();
                }
-                this._verifier = this._createVerifier(method, null, targetDevice);
+                this._verifier = this.createVerifier(method, null, targetDevice);
                if (!this._verifier) {
                    throw newUnknownMethodError();
                }
@@ -407,9 +436,9 @@ export class VerificationRequest extends EventEmitter {
     * sends the initial .request event.
     * @returns {Promise} resolves when the event has been sent.
     */
-    async sendRequest() {
+    public async sendRequest(): Promise<void> {
        if (!this.observeOnly && this._phase === PHASE_UNSENT) {
-            const methods = [...this._verificationMethods.keys()];
+            const methods = [...this.verificationMethods.keys()];
            await this.channel.send(REQUEST_TYPE, { methods });
        }
    }
@@ -420,14 +449,14 @@ export class VerificationRequest extends EventEmitter {
     * @param {string?} error.code the error code to send the cancellation with
     * @returns {Promise} resolves when the event has been sent.
     */
-    async cancel({ reason = "User declined", code = "m.user" } = {}) {
+    public async cancel({ reason = "User declined", code = "m.user" } = {}): Promise<void> {
        if (!this.observeOnly && this._phase !== PHASE_CANCELLED) {
            this._declining = true;
            this.emit("change");
            if (this._verifier) {
                return this._verifier.cancel(errorFactory(code, reason)());
            } else {
-                this._cancellingUserId = this._client.getUserId();
+                this._cancellingUserId = this.client.getUserId();
                await this.channel.send(CANCEL_TYPE, { code, reason });
            }
        }
@@ -437,9 +466,9 @@ export class VerificationRequest extends EventEmitter {
     * Accepts the request, sending a .ready event to the other party
     * @returns {Promise} resolves when the event has been sent.
     */
-    async accept() {
+    public async accept(): Promise<void> {
        if (!this.observeOnly && this.phase === PHASE_REQUESTED && !this.initiatedByMe) {
-            const methods = [...this._verificationMethods.keys()];
+            const methods = [...this.verificationMethods.keys()];
            this._accepting = true;
            this.emit("change");
            await this.channel.send(READY_TYPE, { methods });
@@ -453,7 +482,7 @@ export class VerificationRequest extends EventEmitter {
     * @returns {Promise} that resolves once the callback returns true
     * @throws {Error} when the request is cancelled
     */
-    waitFor(fn) {
+    public waitFor(fn: (request: VerificationRequest) => boolean): Promise<VerificationRequest> {
        return new Promise((resolve, reject) => {
            const check = () => {
                let handled = false;
@@ -475,46 +504,46 @@ export class VerificationRequest extends EventEmitter {
        });
    }

-    _setPhase(phase, notify = true) {
+    private setPhase(phase: Phase, notify = true): void {
        this._phase = phase;
        if (notify) {
            this.emit("change");
        }
    }

-    _getEventByEither(type) {
-        return this._eventsByThem.get(type) || this._eventsByUs.get(type);
+    private getEventByEither(type: string): MatrixEvent {
+        return this.eventsByThem.get(type) || this.eventsByUs.get(type);
    }

-    _getEventBy(type, byThem) {
+    private getEventBy(type: string, byThem = false): MatrixEvent {
        if (byThem) {
-            return this._eventsByThem.get(type);
+            return this.eventsByThem.get(type);
        } else {
-            return this._eventsByUs.get(type);
+            return this.eventsByUs.get(type);
        }
    }

-    _calculatePhaseTransitions() {
-        const transitions = [{ phase: PHASE_UNSENT }];
+    private calculatePhaseTransitions(): ITransition[] {
+        const transitions: ITransition[] = [{ phase: PHASE_UNSENT }];
        const phase = () => transitions[transitions.length - 1].phase;

        // always pass by .request first to be sure channel.userId has been set
-        const hasRequestByThem = this._eventsByThem.has(REQUEST_TYPE);
-        const requestEvent = this._getEventBy(REQUEST_TYPE, hasRequestByThem);
+        const hasRequestByThem = this.eventsByThem.has(REQUEST_TYPE);
+        const requestEvent = this.getEventBy(REQUEST_TYPE, hasRequestByThem);
        if (requestEvent) {
            transitions.push({ phase: PHASE_REQUESTED, event: requestEvent });
        }

        const readyEvent =
-            requestEvent && this._getEventBy(READY_TYPE, !hasRequestByThem);
+            requestEvent && this.getEventBy(READY_TYPE, !hasRequestByThem);
        if (readyEvent && phase() === PHASE_REQUESTED) {
            transitions.push({ phase: PHASE_READY, event: readyEvent });
        }

        let startEvent;
        if (readyEvent || !requestEvent) {
-            const theirStartEvent = this._eventsByThem.get(START_TYPE);
-            const ourStartEvent = this._eventsByUs.get(START_TYPE);
+            const theirStartEvent = this.eventsByThem.get(START_TYPE);
+            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() ?
@@ -523,24 +552,22 @@ export class VerificationRequest extends EventEmitter {
                startEvent = theirStartEvent ? theirStartEvent : ourStartEvent;
            }
        } else {
-            startEvent = this._getEventBy(START_TYPE, !hasRequestByThem);
+            startEvent = this.getEventBy(START_TYPE, !hasRequestByThem);
        }
        if (startEvent) {
-            const fromRequestPhase = phase() === PHASE_REQUESTED &&
-                requestEvent.getSender() !== startEvent.getSender();
-            const fromUnsentPhase = phase() === PHASE_UNSENT &&
-                this.channel.constructor.canCreateRequest(START_TYPE);
+            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 });
            }
        }

-        const ourDoneEvent = this._eventsByUs.get(DONE_TYPE);
-        if (this._verifierHasFinished || (ourDoneEvent && phase() === PHASE_STARTED)) {
+        const ourDoneEvent = this.eventsByUs.get(DONE_TYPE);
+        if (this.verifierHasFinished || (ourDoneEvent && phase() === PHASE_STARTED)) {
            transitions.push({ phase: PHASE_DONE });
        }

-        const cancelEvent = this._getEventByEither(CANCEL_TYPE);
+        const cancelEvent = this.getEventByEither(CANCEL_TYPE);
        if ((this._cancelled || cancelEvent) && phase() !== PHASE_DONE) {
            transitions.push({ phase: PHASE_CANCELLED, event: cancelEvent });
            return transitions;
@@ -549,14 +576,14 @@ export class VerificationRequest extends EventEmitter {
        return transitions;
    }

-    _transitionToPhase(transition) {
+    private transitionToPhase(transition: ITransition): void {
        const { phase, event } = transition;
        // get common methods
        if (phase === PHASE_REQUESTED || phase === PHASE_READY) {
-            if (!this._wasSentByOwnDevice(event)) {
+            if (!this.wasSentByOwnDevice(event)) {
                const content = event.getContent();
-                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
@@ -568,8 +595,8 @@ export class VerificationRequest extends EventEmitter {
            ) {
                if (
                    this.channel.receiveStartFromOtherDevices &&
-                    this._wasSentByOwnUser(event) &&
-                    !this._wasSentByOwnDevice(event)
+                    this.wasSentByOwnUser(event) &&
+                    !this.wasSentByOwnDevice(event)
                ) {
                    this._observeOnly = true;
                }
@@ -579,7 +606,7 @@ export class VerificationRequest extends EventEmitter {
        if (phase === PHASE_STARTED) {
            const { method } = event.getContent();
            if (!this._verifier && !this.observeOnly) {
-                this._verifier = this._createVerifier(method, event);
+                this._verifier = this.createVerifier(method, event);
                if (!this._verifier) {
                    this.cancel({
                        code: "m.unknown_method",
@@ -592,19 +619,19 @@ export class VerificationRequest extends EventEmitter {
        }
    }

-    _applyPhaseTransitions() {
-        const transitions = this._calculatePhaseTransitions();
+    private applyPhaseTransitions(): ITransition[] {
+        const transitions = this.calculatePhaseTransitions();
        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
        for (const transition of newTransitions) {
-            this._transitionToPhase(transition);
+            this.transitionToPhase(transition);
        }
        return newTransitions;
    }

-    _isWinningStartRace(newEvent) {
+    private isWinningStartRace(newEvent: MatrixEvent): boolean {
        if (newEvent.getType() !== START_TYPE) {
            return false;
        }
@@ -620,13 +647,13 @@ export class VerificationRequest extends EventEmitter {
                const oldContent = oldEvent.getContent();
                oldRaceIdentifier = oldContent && oldContent.from_device;
            } else {
-                oldRaceIdentifier = this._client.getDeviceId();
+                oldRaceIdentifier = this.client.getDeviceId();
            }
        } else {
            if (oldEvent) {
                oldRaceIdentifier = oldEvent.getSender();
            } else {
-                oldRaceIdentifier = this._client.getUserId();
+                oldRaceIdentifier = this.client.getUserId();
            }
        }

@@ -640,13 +667,13 @@ export class VerificationRequest extends EventEmitter {
        return newRaceIdentifier < oldRaceIdentifier;
    }

-    hasEventId(eventId) {
-        for (const event of this._eventsByUs.values()) {
+    public hasEventId(eventId: string): boolean {
+        for (const event of this.eventsByUs.values()) {
            if (event.getId() === eventId) {
                return true;
            }
        }
-        for (const event of this._eventsByThem.values()) {
+        for (const event of this.eventsByThem.values()) {
            if (event.getId() === eventId) {
                return true;
            }
@@ -658,23 +685,29 @@ export class VerificationRequest extends EventEmitter {
     * 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 {bool} isLiveEvent whether this is an even received through sync or not
-     * @param {bool} isRemoteEcho whether this is the remote echo of an event sent by the same device
-     * @param {bool} isSentByUs whether this event is sent by a party that can accept and/or observe the request like one of our peers.
+     * @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.
     *   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 anwser to the passed-in event are sent.
+     * @returns {Promise} a promise that resolves when any requests as an answer to the passed-in event are sent.
     */
-    async handleEvent(type, event, isLiveEvent, isRemoteEcho, isSentByUs) {
+    public async handleEvent(
+        type: string,
+        event: MatrixEvent,
+        isLiveEvent: boolean,
+        isRemoteEcho: boolean,
+        isSentByUs: boolean,
+    ): Promise<void> {
        // if reached phase cancelled or done, ignore anything else that comes
        if (this.done || this.cancelled) {
            return;
        }
        const wasObserveOnly = this._observeOnly;

-        this._adjustObserveOnly(event, isLiveEvent);
+        this.adjustObserveOnly(event, isLiveEvent);

        if (!this.observeOnly && !isRemoteEcho) {
-            if (await this._cancelOnError(type, event)) {
+            if (await this.cancelOnError(type, event)) {
                return;
            }
        }
@@ -685,27 +718,26 @@ export class VerificationRequest extends EventEmitter {
        // 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);
+            this.eventsByUs.has(type) :
+            this.eventsByThem.has(type);
        if (isDuplicateEvent) {
            return;
        }

        const oldPhase = this.phase;
-        this._addEvent(type, event, isSentByUs);
+        this.addEvent(type, event, isSentByUs);

        // this will create if needed the verifier so needs to happen before calling it
-        const newTransitions = this._applyPhaseTransitions();
+        const newTransitions = this.applyPhaseTransitions();
        try {
            // only pass events from the other side to the verifier,
            // no remote echos of our own events
            if (this._verifier && !this.observeOnly) {
-                const newEventWinsRace = this._isWinningStartRace(event);
+                const newEventWinsRace = this.isWinningStartRace(event);
                if (this._verifier.canSwitchStartEvent(event) && newEventWinsRace) {
                    this._verifier.switchStartEvent(event);
                } else if (!isRemoteEcho) {
-                    if (type === CANCEL_TYPE || (this._verifier.events
-                        && this._verifier.events.includes(type))) {
+                    if (type === CANCEL_TYPE || this._verifier.events?.includes(type)) {
                        this._verifier.handleEvent(event);
                    }
                }
@@ -722,16 +754,16 @@ export class VerificationRequest extends EventEmitter {
                    const shouldGenerateQrCode =
                        this.otherPartySupportsMethod(SCAN_QR_CODE_METHOD, true);
                    if (shouldGenerateQrCode) {
-                        this._qrCodeData = await QRCodeData.create(this, this._client);
+                        this._qrCodeData = await QRCodeData.create(this, this.client);
                    }
                }

                const lastTransition = newTransitions[newTransitions.length - 1];
                const { phase } = lastTransition;

-                this._setupTimeout(phase);
+                this.setupTimeout(phase);
                // set phase as last thing as this emits the "change" event
-                this._setPhase(phase);
+                this.setPhase(phase);
            } else if (this._observeOnly !== wasObserveOnly) {
                this.emit("change");
            }
@@ -748,26 +780,26 @@ export class VerificationRequest extends EventEmitter {
        }
    }

-    _setupTimeout(phase) {
-        const shouldTimeout = !this._timeoutTimer && !this.observeOnly &&
+    private setupTimeout(phase: Phase): void {
+        const shouldTimeout = !this.timeoutTimer && !this.observeOnly &&
            phase === PHASE_REQUESTED;

        if (shouldTimeout) {
-            this._timeoutTimer = setTimeout(this._cancelOnTimeout, this.timeout);
+            this.timeoutTimer = setTimeout(this.cancelOnTimeout, this.timeout);
        }
-        if (this._timeoutTimer) {
+        if (this.timeoutTimer) {
            const shouldClear = phase === PHASE_STARTED ||
                phase === PHASE_READY ||
                phase === PHASE_DONE ||
                phase === PHASE_CANCELLED;
            if (shouldClear) {
-                clearTimeout(this._timeoutTimer);
-                this._timeoutTimer = null;
+                clearTimeout(this.timeoutTimer);
+                this.timeoutTimer = null;
            }
        }
    }

-    _cancelOnTimeout = () => {
+    private cancelOnTimeout = () => {
        try {
            if (this.initiatedByMe) {
                this.cancel({
@@ -785,10 +817,10 @@ export class VerificationRequest extends EventEmitter {
        }
    };

-    async _cancelOnError(type, event) {
+    private async cancelOnError(type: string, event: MatrixEvent): Promise<boolean> {
        if (type === START_TYPE) {
            const method = event.getContent().method;
-            if (!this._verificationMethods.has(method)) {
+            if (!this.verificationMethods.has(method)) {
                await this.cancel(errorFromEvent(newUnknownMethodError()));
                return true;
            }
@@ -811,7 +843,7 @@ export class VerificationRequest extends EventEmitter {
        return false;
    }

-    _adjustObserveOnly(event, isLiveEvent) {
+    private adjustObserveOnly(event: MatrixEvent, isLiveEvent = false): void {
        // don't send out events for historical requests
        if (!isLiveEvent) {
            this._observeOnly = true;
@@ -821,83 +853,80 @@ export class VerificationRequest extends EventEmitter {
        }
    }

-    _addEvent(type, event, isSentByUs) {
+    private addEvent(type: string, event: MatrixEvent, isSentByUs = false): void {
        if (isSentByUs) {
-            this._eventsByUs.set(type, event);
+            this.eventsByUs.set(type, event);
        } else {
-            this._eventsByThem.set(type, event);
+            this.eventsByThem.set(type, event);
        }

        // once we know the userId of the other party (from the .request event)
-        // see if any event by anyone else crept into this._eventsByThem
+        // see if any event by anyone else crept into this.eventsByThem
        if (type === REQUEST_TYPE) {
-            for (const [type, event] of this._eventsByThem.entries()) {
+            for (const [type, event] of this.eventsByThem.entries()) {
                if (event.getSender() !== this.otherUserId) {
-                    this._eventsByThem.delete(type);
+                    this.eventsByThem.delete(type);
                }
            }
            // also remember when we received the request event
-            this._requestReceivedAt = Date.now();
+            this.requestReceivedAt = Date.now();
        }
    }

-    _createVerifier(method, startEvent = null, targetDevice = null) {
+    private createVerifier(
+        method: VerificationMethod,
+        startEvent: MatrixEvent = null,
+        targetDevice: ITargetDevice = null,
+    ): VerificationBase {
        if (!targetDevice) {
            targetDevice = this.targetDevice;
        }
        const { userId, deviceId } = targetDevice;

-        const VerifierCtor = this._verificationMethods.get(method);
+        const VerifierCtor = this.verificationMethods.get(method);
        if (!VerifierCtor) {
            logger.warn("could not find verifier constructor for method", method);
            return;
        }
-        return new VerifierCtor(
-            this.channel,
-            this._client,
-            userId,
-            deviceId,
-            startEvent,
-            this,
-        );
+        return new VerifierCtor(this.channel, this.client, userId, deviceId, startEvent, this);
    }

-    _wasSentByOwnUser(event) {
-        return event.getSender() === this._client.getUserId();
+    private wasSentByOwnUser(event: MatrixEvent): boolean {
+        return event.getSender() === this.client.getUserId();
    }

    // only for .request, .ready or .start
-    _wasSentByOwnDevice(event) {
-        if (!this._wasSentByOwnUser(event)) {
+    private wasSentByOwnDevice(event: MatrixEvent): boolean {
+        if (!this.wasSentByOwnUser(event)) {
            return false;
        }
        const content = event.getContent();
-        if (!content || content.from_device !== this._client.getDeviceId()) {
+        if (!content || content.from_device !== this.client.getDeviceId()) {
            return false;
        }
        return true;
    }

-    onVerifierCancelled() {
+    public onVerifierCancelled(): void {
        this._cancelled = true;
        // move to cancelled phase
-        const newTransitions = this._applyPhaseTransitions();
+        const newTransitions = this.applyPhaseTransitions();
        if (newTransitions.length) {
-            this._setPhase(newTransitions[newTransitions.length - 1].phase);
+            this.setPhase(newTransitions[newTransitions.length - 1].phase);
        }
    }

-    onVerifierFinished() {
+    public onVerifierFinished(): void {
        this.channel.send("m.key.verification.done", {});
-        this._verifierHasFinished = true;
+        this.verifierHasFinished = true;
        // move to .done phase
-        const newTransitions = this._applyPhaseTransitions();
+        const newTransitions = this.applyPhaseTransitions();
        if (newTransitions.length) {
-            this._setPhase(newTransitions[newTransitions.length - 1].phase);
+            this.setPhase(newTransitions[newTransitions.length - 1].phase);
        }
    }

-    getEventFromOtherParty(type) {
-        return this._eventsByThem.get(type);
+    public getEventFromOtherParty(type: string): MatrixEvent {
+        return this.eventsByThem.get(type);
    }
 }
@@ -60,7 +60,7 @@ log.methodFactory = function(methodName, logLevel, loggerName) {
 * Can be tailored down to specific use cases if needed.
 */
 export const logger: PrefixedLogger = log.getLogger(DEFAULT_NAMESPACE);
-logger.setLevel(log.levels.DEBUG);
+logger.setLevel(log.levels.DEBUG, false);

 export interface PrefixedLogger extends Logger {
    withPrefix?: (prefix: string) => PrefixedLogger;
@@ -82,7 +82,7 @@ function getPrefixedLogger(prefix): PrefixedLogger {
        // Only do this setup work the first time through, as loggers are saved by name.
        extendLogger(prefixLogger);
        prefixLogger.prefix = prefix;
-        prefixLogger.setLevel(log.levels.DEBUG);
+        prefixLogger.setLevel(log.levels.DEBUG, false);
    }
    return prefixLogger;
 }
@@ -49,8 +49,6 @@ export * from "./content-repo";
 export * as ContentHelpers from "./content-helpers";
 export {
    createNewMatrixCall,
-    setAudioInput as setMatrixCallAudioInput,
-    setVideoInput as setMatrixCallVideoInput,
 } from "./webrtc/call";

 // expose the underlying request object so different environments can use
@@ -15,8 +15,9 @@ limitations under the License.
 */

 import { MatrixClient } from "../client";
-import { IEncryptedFile, UNSTABLE_MSC3089_BRANCH } from "../@types/event";
-import { MatrixEvent } from "./event";
+import { IEncryptedFile, RelationType, UNSTABLE_MSC3089_BRANCH } from "../@types/event";
+import { IContent, MatrixEvent } from "./event";
+import { MSC3089TreeSpace } from "./MSC3089TreeSpace";

 /**
 * Represents a [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) branch - a reference
@@ -24,7 +25,11 @@ import { MatrixEvent } from "./event";
 * without notice.
 */
 export class MSC3089Branch {
-    public constructor(private client: MatrixClient, public readonly indexEvent: MatrixEvent) {
+    public constructor(
+        private client: MatrixClient,
+        public readonly indexEvent: MatrixEvent,
+        public readonly directory: MSC3089TreeSpace,
+    ) {
        // Nothing to do
    }

@@ -42,19 +47,27 @@ export class MSC3089Branch {
        return this.indexEvent.getContent()["active"] === true;
    }

+    /**
+     * Version for the file, one-indexed.
+     */
+    public get version(): number {
+        return this.indexEvent.getContent()["version"] ?? 1;
+    }
+
    private get roomId(): string {
        return this.indexEvent.getRoomId();
    }

    /**
-     * Deletes the file from the tree.
+     * Deletes the file from the tree, including all prior edits/versions.
     * @returns {Promise<void>} Resolves when complete.
     */
    public async delete(): Promise<void> {
        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {}, this.id);
        await this.client.redactEvent(this.roomId, this.id);

-        // TODO: Delete edit history as well
+        const nextVersion = (await this.getVersionHistory())[1]; // [0] will be us
+        if (nextVersion) await nextVersion.delete(); // implicit recursion
    }

    /**
@@ -77,6 +90,26 @@ export class MSC3089Branch {
        }, this.id);
    }

+    /**
+     * Gets whether or not a file is locked.
+     * @returns {boolean} True if locked, false otherwise.
+     */
+    public isLocked(): boolean {
+        return this.indexEvent.getContent()['locked'] || false;
+    }
+
+    /**
+     * Sets a file as locked or unlocked.
+     * @param {boolean} locked True to lock the file, false otherwise.
+     * @returns {Promise<void>} 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);
+    }
+
    /**
     * Gets information about the file needed to download it.
     * @returns {Promise<{info: IEncryptedFile, httpUrl: string}>} Information about the file.
@@ -84,7 +117,7 @@ export class MSC3089Branch {
    public async getFileInfo(): Promise<{ info: IEncryptedFile, httpUrl: string }> {
        const event = await this.getFileEvent();

-        const file = event.getContent()['file'];
+        const file = event.getOriginalContent()['file'];
        const httpUrl = this.client.mxcUrlToHttp(file['url']);

        return { info: file, httpUrl: httpUrl };
@@ -98,15 +131,88 @@ export class MSC3089Branch {
        const room = this.client.getRoom(this.roomId);
        if (!room) throw new Error("Unknown room");

-        const timeline = await this.client.getEventTimeline(room.getUnfilteredTimelineSet(), this.id);
-        if (!timeline) throw new Error("Failed to get timeline for room event");
-
-        const event = timeline.getEvents().find(e => e.getId() === this.id);
+        const event = room.getUnfilteredTimelineSet().findEventById(this.id);
        if (!event) throw new Error("Failed to find event");

-        // Sometimes the event context doesn't decrypt for us, so do that.
-        await this.client.decryptEventIfNeeded(event, { emit: false, isRetry: false });
+        // Sometimes the event isn't decrypted for us, so do that. We specifically set `emit: true`
+        // to ensure that the relations system in the sdk will function.
+        await this.client.decryptEventIfNeeded(event, { emit: true, isRetry: true });

        return event;
    }
+
+    /**
+     * Creates a new version of this file.
+     * @param {string} name The name of the file.
+     * @param {ArrayBuffer} 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<void>} Resolves when uploaded.
+     */
+    public async createNewVersion(
+        name: string,
+        encryptedContents: ArrayBuffer,
+        info: Partial<IEncryptedFile>,
+        additionalContent?: IContent,
+    ): Promise<void> {
+        const fileEventResponse = await this.directory.createFile(name, encryptedContents, info, {
+            ...(additionalContent ?? {}),
+            "m.new_content": true,
+            "m.relates_to": {
+                "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']);
+
+        // Deprecate ourselves
+        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
+            ...(this.indexEvent.getContent()),
+            active: false,
+        }, this.id);
+    }
+
+    /**
+     * Gets the file's version history, starting at this file.
+     * @returns {Promise<MSC3089Branch[]>} 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[]> {
+        const fileHistory: MSC3089Branch[] = [];
+        fileHistory.push(this); // start with ourselves
+
+        const room = this.client.getRoom(this.roomId);
+        if (!room) throw new Error("Invalid or unknown room");
+
+        // Clone the timeline to reverse it, getting most-recent-first ordering, hopefully
+        // shortening the awful loop below. Without the clone, we can unintentionally mutate
+        // the timeline.
+        const timelineEvents = [...room.getLiveTimeline().getEvents()].reverse();
+
+        // XXX: This is a very inefficient search, but it's the best we can do with the
+        // relations structure we have in the SDK. As of writing, it is not worth the
+        // investment in improving the structure.
+        let childEvent: MatrixEvent;
+        let parentEvent = await this.getFileEvent();
+        do {
+            childEvent = timelineEvents.find(e => e.replacingEventId() === parentEvent.getId());
+            if (childEvent) {
+                const branch = this.directory.getFile(childEvent.getId());
+                if (branch) {
+                    fileHistory.push(branch);
+                    parentEvent = childEvent;
+                } else {
+                    break; // prevent infinite loop
+                }
+            }
+        } while (childEvent);
+
+        return fileHistory;
+    }
 }
@@ -30,6 +30,7 @@ import {
 import { MSC3089Branch } from "./MSC3089Branch";
 import promiseRetry from "p-retry";
 import { isRoomSharedHistory } from "../crypto/algorithms/megolm";
+import { ISendEventResponse } from "../@types/requests";

 /**
 * The recommended defaults for a tree space's power levels. Note that this
@@ -452,26 +453,38 @@ export class MSC3089TreeSpace {
     * @param {ArrayBuffer} 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<void>} Resolves when uploaded.
+     * @returns {Promise<ISendEventResponse>} Resolves to the file event's sent response.
     */
    public async createFile(
        name: string,
        encryptedContents: ArrayBuffer,
        info: Partial<IEncryptedFile>,
        additionalContent?: IContent,
-    ): Promise<void> {
+    ): Promise<ISendEventResponse> {
        const mxc = await this.client.uploadContent(new Blob([encryptedContents]), {
            includeFilename: false,
            onlyContentUri: true,
        });
        info.url = mxc;

-        const res = await this.client.sendMessage(this.roomId, {
-            ...(additionalContent ?? {}),
+        const fileContent = {
            msgtype: MsgType.File,
            body: name,
            url: mxc,
            file: info,
+        };
+
+        additionalContent = additionalContent ?? {};
+        if (additionalContent["m.new_content"]) {
+            // We do the right thing according to the spec, but due to how relations are
+            // handled we also end up duplicating this information to the regular `content`
+            // as well.
+            additionalContent["m.new_content"] = fileContent;
+        }
+
+        const res = await this.client.sendMessage(this.roomId, {
+            ...additionalContent,
+            ...fileContent,
            [UNSTABLE_MSC3089_LEAF.name]: {},
        });

@@ -479,6 +492,8 @@ export class MSC3089TreeSpace {
            active: true,
            name: name,
        }, res['event_id']);
+
+        return res;
    }

    /**
@@ -488,7 +503,7 @@ export class MSC3089TreeSpace {
     */
    public getFile(fileEventId: string): MSC3089Branch {
        const branch = this.room.currentState.getStateEvents(UNSTABLE_MSC3089_BRANCH.name, fileEventId);
-        return branch ? new MSC3089Branch(this.client, branch) : null;
+        return branch ? new MSC3089Branch(this.client, branch, this) : null;
    }

    /**
@@ -496,7 +511,15 @@ export class MSC3089TreeSpace {
     * @returns {MSC3089Branch[]} The known files. May be empty, but not null.
     */
    public listFiles(): MSC3089Branch[] {
+        return this.listAllFiles().filter(b => b.isActive);
+    }
+
+    /**
+     * 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.
+     */
+    public listAllFiles(): MSC3089Branch[] {
        const branches = this.room.currentState.getStateEvents(UNSTABLE_MSC3089_BRANCH.name) ?? [];
-        return branches.map(e => new MSC3089Branch(this.client, e)).filter(b => b.isActive);
+        return branches.map(e => new MSC3089Branch(this.client, e, this));
    }
 }
@@ -27,6 +27,7 @@ import { Relations } from './relations';
 import { Room } from "./room";
 import { Filter } from "../filter";
 import { EventType, RelationType } from "../@types/event";
+import { RoomState } from "./room-state";

 // var DEBUG = false;
 const DEBUG = true;
@@ -45,6 +46,11 @@ interface IOpts {
    unstableClientRelationAggregation?: boolean;
 }

+export enum DuplicateStrategy {
+    Ignore = "ignore",
+    Replace = "replace",
+}
+
 export class EventTimelineSet extends EventEmitter {
    private readonly timelineSupport: boolean;
    private unstableClientRelationAggregation: boolean;
@@ -509,8 +515,14 @@ export class EventTimelineSet extends EventEmitter {
     * @param {MatrixEvent} event Event to be added
     * @param {string?} duplicateStrategy 'ignore' or 'replace'
     * @param {boolean} fromCache whether the sync response came from cache
+     * @param roomState the state events to reconcile metadata from
     */
-    public addLiveEvent(event: MatrixEvent, duplicateStrategy?: "ignore" | "replace", fromCache = false): void {
+    public addLiveEvent(
+        event: MatrixEvent,
+        duplicateStrategy: DuplicateStrategy = DuplicateStrategy.Ignore,
+        fromCache = false,
+        roomState?: RoomState,
+    ): void {
        if (this.filter) {
            const events = this.filter.filterRoomTimeline([event]);
            if (!events.length) {
@@ -520,16 +532,19 @@ export class EventTimelineSet extends EventEmitter {

        const timeline = this._eventIdToTimeline[event.getId()];
        if (timeline) {
-            if (duplicateStrategy === "replace") {
+            if (duplicateStrategy === DuplicateStrategy.Replace) {
                debuglog("EventTimelineSet.addLiveEvent: replacing duplicate event " +
                    event.getId());
                const tlEvents = timeline.getEvents();
                for (let j = 0; j < tlEvents.length; j++) {
                    if (tlEvents[j].getId() === event.getId()) {
                        // still need to set the right metadata on this event
+                        if (!roomState) {
+                            roomState = timeline.getState(EventTimeline.FORWARDS);
+                        }
                        EventTimeline.setEventMetadata(
                            event,
-                            timeline.getState(EventTimeline.FORWARDS),
+                            roomState,
                            false,
                        );
                        tlEvents[j] = event;
@@ -545,7 +560,7 @@ export class EventTimelineSet extends EventEmitter {
            return;
        }

-        this.addEventToTimeline(event, this.liveTimeline, false, fromCache);
+        this.addEventToTimeline(event, this.liveTimeline, false, fromCache, roomState);
    }

    /**
@@ -566,9 +581,10 @@ export class EventTimelineSet extends EventEmitter {
        timeline: EventTimeline,
        toStartOfTimeline: boolean,
        fromCache = false,
+        roomState?: RoomState,
    ) {
        const eventId = event.getId();
-        timeline.addEvent(event, toStartOfTimeline);
+        timeline.addEvent(event, toStartOfTimeline, roomState);
        this._eventIdToTimeline[eventId] = timeline;

        this.setRelationsTarget(event);
@@ -347,8 +347,11 @@ export class EventTimeline {
     * @param {MatrixEvent} event   new event
     * @param {boolean}  atStart     true to insert new event at the start
     */
-    public addEvent(event: MatrixEvent, atStart: boolean): void {
-        const stateContext = atStart ? this.startState : this.endState;
+    public addEvent(event: MatrixEvent, atStart: boolean, stateContext?: RoomState): void {
+        if (!stateContext) {
+            stateContext = atStart ? this.startState : this.endState;
+        }
+
        const timelineSet = this.getTimelineSet();

        if (timelineSet.room) {
@@ -28,12 +28,11 @@ import {
    EventType,
    MsgType,
    RelationType,
-    UNSTABLE_ELEMENT_REPLY_IN_THREAD,
 } from "../@types/event";
 import { Crypto } from "../crypto";
 import { deepSortedObjectEntries } from "../utils";
 import { RoomMember } from "./room-member";
-import { Thread } from "./thread";
+import { Thread, ThreadEvent } from "./thread";
 import { IActionsObject } from '../pushprocessor';
 import { ReEmitter } from '../ReEmitter';

@@ -119,7 +118,7 @@ interface IAggregatedRelation {
    key?: string;
 }

-interface IEventRelation {
+export interface IEventRelation {
    rel_type: RelationType | string;
    event_id: string;
    key?: string;
@@ -285,8 +284,28 @@ export class MatrixEvent extends EventEmitter {
     * @returns {IEvent} The event in wire format.
     */
    public getEffectiveEvent(): IEvent {
-        // clearEvent doesn't have all the fields, so we'll copy what we can from this.event
-        return Object.assign({}, this.event, this.clearEvent) as IEvent;
+        const content = Object.assign({}, this.getContent()); // clone for mutation
+
+        if (this.getWireType() === EventType.RoomMessageEncrypted) {
+            // Encrypted events sometimes aren't symmetrical on the `content` so we'll copy
+            // that over too, but only for missing properties. We don't copy over mismatches
+            // between the plain and decrypted copies of `content` because we assume that the
+            // app is relying on the decrypted version, so we want to expose that as a source
+            // of truth here too.
+            for (const [key, value] of Object.entries(this.getWireContent())) {
+                // Skip fields from the encrypted event schema though - we don't want to leak
+                // these.
+                if (["algorithm", "ciphertext", "device_id", "sender_key", "session_id"].includes(key)) {
+                    continue;
+                }
+
+                if (content[key] === undefined) content[key] = value;
+            }
+        }
+
+        // clearEvent doesn't have all the fields, so we'll copy what we can from this.event.
+        // We also copy over our "fixed" content key.
+        return Object.assign({}, this.event, this.clearEvent, { content }) as IEvent;
    }

    /**
@@ -399,25 +418,39 @@ export class MatrixEvent extends EventEmitter {

    /**
     * @experimental
-     * Get the event ID of the replied event
+     * Get the event ID of the thread head
     */
-    public get replyEventId(): string {
-        const relations = this.getWireContent()["m.relates_to"];
-        return relations?.["m.in_reply_to"]?.["event_id"];
+    public get threadRootId(): string {
+        const relatesTo = this.getWireContent()?.["m.relates_to"];
+        if (relatesTo?.rel_type === RelationType.Thread) {
+            return relatesTo.event_id;
+        }
    }

    /**
     * @experimental
-     * Determines whether a reply should be rendered in a thread
-     * or in the main room timeline
     */
-    public get replyInThread(): boolean {
-        const replyTo = this.getWireContent()
-            ?.["m.relates_to"]
-            ?.["m.in_reply_to"];
-        return (this.replyEventId
-            && replyTo[UNSTABLE_ELEMENT_REPLY_IN_THREAD.name])
-            || this.thread instanceof Thread;
+    public get isThreadRelation(): boolean {
+        return !!this.threadRootId;
+    }
+
+    /**
+     * @experimental
+     */
+    public get isThreadRoot(): boolean {
+        const thread = this.getThread();
+        return thread?.id === this.getId();
+    }
+
+    public get parentEventId(): string {
+        const relations = this.getWireContent()["m.relates_to"];
+        return relations?.["m.in_reply_to"]?.["event_id"]
+            || relations?.event_id;
+    }
+
+    public get replyEventId(): string {
+        const relations = this.getWireContent()["m.relates_to"];
+        return relations?.["m.in_reply_to"]?.["event_id"];
    }

    /**
@@ -1316,7 +1349,7 @@ export class MatrixEvent extends EventEmitter {
     */
    public setThread(thread: Thread): void {
        this.thread = thread;
-        this.reEmitter.reEmit(thread, ["Thread.ready", "Thread.update"]);
+        this.reEmitter.reEmit(thread, [ThreadEvent.Ready, ThreadEvent.Update]);
    }

    /**
@@ -103,7 +103,7 @@ export class RoomMember extends EventEmitter {
     * @fires module:client~MatrixClient#event:"RoomMember.name"
     * @fires module:client~MatrixClient#event:"RoomMember.membership"
     */
-    public setMembershipEvent(event: MatrixEvent, roomState: RoomState): void {
+    public setMembershipEvent(event: MatrixEvent, roomState?: RoomState): void {
        const displayName = event.getDirectionalContent().displayname;

        if (event.getType() !== "m.room.member") {
@@ -322,7 +322,7 @@ export class RoomMember extends EventEmitter {
 const MXID_PATTERN = /@.+:.+/;
 const LTR_RTL_PATTERN = /[\u200E\u200F\u202A-\u202F]/;

-function shouldDisambiguate(selfUserId: string, displayName: string, roomState: RoomState): boolean {
+function shouldDisambiguate(selfUserId: string, displayName: string, roomState?: RoomState): boolean {
    if (!displayName || displayName === selfUserId) return false;

    // First check if the displayname is something we consider truthy
@@ -26,7 +26,7 @@ import * as utils from "../utils";
 import { EventType } from "../@types/event";
 import { MatrixEvent } from "./event";
 import { MatrixClient } from "../client";
-import { IJoinRuleEventContent, JoinRule } from "../@types/partials";
+import { GuestAccess, HistoryVisibility, IJoinRuleEventContent, JoinRule } from "../@types/partials";

 // possible statuses for out-of-band member loading
 enum OobStatus {
@@ -578,7 +578,7 @@ export class RoomState extends EventEmitter {
     * @param {number} powerLevel The power level of the member
     * @return {boolean} true if the given power level is sufficient
     */
-    private hasSufficientPowerLevelFor(action: string, powerLevel: number): boolean {
+    public hasSufficientPowerLevelFor(action: string, powerLevel: number): boolean {
        const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, "");

        let powerLevels = {};
@@ -735,6 +735,26 @@ export class RoomState extends EventEmitter {
        return joinRuleContent["join_rule"] || JoinRule.Invite;
    }

+    /**
+     * 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
+     */
+    public getHistoryVisibility(): HistoryVisibility {
+        const historyVisibilityEvent = this.getStateEvents(EventType.RoomHistoryVisibility, "");
+        const historyVisibilityContent = historyVisibilityEvent?.getContent() ?? {};
+        return historyVisibilityContent["history_visibility"] || HistoryVisibility.Shared;
+    }
+
+    /**
+     * 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
+     */
+    public getGuestAccess(): GuestAccess {
+        const guestAccessEvent = this.getStateEvents(EventType.RoomGuestAccess, "");
+        const guestAccessContent = guestAccessEvent?.getContent() ?? {};
+        return guestAccessContent["guest_access"] || GuestAccess.Forbidden;
+    }
+
    private updateThirdPartyTokenCache(memberEvent: MatrixEvent): void {
        if (!memberEvent.getContent().third_party_invite) {
            return;
@@ -20,7 +20,7 @@ limitations under the License.

 import { EventEmitter } from "events";

-import { EventTimelineSet } from "./event-timeline-set";
+import { EventTimelineSet, DuplicateStrategy } from "./event-timeline-set";
 import { EventTimeline } from "./event-timeline";
 import { getHttpUriForMxc } from "../content-repo";
 import * as utils from "../utils";
@@ -32,10 +32,10 @@ import { logger } from '../logger';
 import { ReEmitter } from '../ReEmitter';
 import { EventType, RoomCreateTypeField, RoomType, UNSTABLE_ELEMENT_FUNCTIONAL_USERS } from "../@types/event";
 import { IRoomVersionsCapability, MatrixClient, PendingEventOrdering, RoomVersionStability } from "../client";
-import { JoinRule, ResizeMethod } from "../@types/partials";
+import { GuestAccess, HistoryVisibility, JoinRule, ResizeMethod } from "../@types/partials";
 import { Filter } from "../filter";
 import { RoomState } from "./room-state";
-import { Thread } from "./thread";
+import { Thread, ThreadEvent } from "./thread";

 // These constants are used as sane defaults when the homeserver doesn't support
 // the m.room_versions capability. In practice, KNOWN_SAFE_ROOM_VERSION should be
@@ -149,7 +149,7 @@ export class Room extends EventEmitter {
    /**
     * @experimental
     */
-    public threads = new Set<Thread>();
+    public threads = new Map<string, Thread>();

    /**
     * Construct a new Room.
@@ -1068,19 +1068,6 @@ export class Room extends EventEmitter {
        );
    }

-    /**
-     * @experimental
-     */
-    public addThread(thread: Thread): Set<Thread> {
-        this.threads.add(thread);
-        if (!thread.ready) {
-            thread.once("Thread.ready", this.dedupeThreads);
-            this.emit("Thread.update", thread);
-            this.reEmitter.reEmit(thread, ["Thread.update", "Thread.ready"]);
-        }
-        return this.threads;
-    }
-
    /**
     * @experimental
     */
@@ -1097,26 +1084,6 @@ export class Room extends EventEmitter {
        return Array.from(this.threads.values());
    }

-    /**
-     * Two threads starting from a different child event can end up
-     * with the same event root. This method ensures that the duplicates
-     * are removed
-     * @experimental
-     */
-    private dedupeThreads = (readyThread): void => {
-        const deduped = Array.from(this.threads).reduce((dedupedThreads, thread) => {
-            if (dedupedThreads.has(thread.id)) {
-                dedupedThreads.get(thread.id).merge(thread);
-            } else {
-                dedupedThreads.set(thread.id, thread);
-            }
-
-            return dedupedThreads;
-        }, new Map<string, Thread>());
-
-        this.threads = new Set<Thread>(deduped.values());
-    };
-
    /**
     * Get a member from the current room state.
     * @param {string} userId The user ID of the member.
@@ -1293,26 +1260,38 @@ export class Room extends EventEmitter {
        }
    }

+    public findThreadForEvent(event: MatrixEvent): Thread {
+        if (!event) {
+            return null;
+        }
+        if (event.isThreadRelation) {
+            return this.threads.get(event.threadRootId);
+        } else {
+            const parentEvent = this.findEventById(event.parentEventId);
+            return this.findThreadForEvent(parentEvent);
+        }
+    }
+
    /**
     * Add an event to a thread's timeline. Will fire "Thread.update"
     * @experimental
     */
    public addThreadedEvent(event: MatrixEvent): void {
-        if (event.getUnsigned().transaction_id) {
-            const existingEvent = this.txnToEvent[event.getUnsigned().transaction_id];
-            if (existingEvent) {
-                // remote echo of an event we sent earlier
-                this.handleRemoteEcho(event, existingEvent);
-            }
-        }
-
-        let thread = this.findEventById(event.replyEventId)?.getThread();
+        let thread = this.findThreadForEvent(event);
        if (thread) {
            thread.addEvent(event);
        } else {
-            thread = new Thread([event], this, this.client);
-            this.addThread(thread);
+            const events = [event];
+            const rootEvent = this.findEventById(event.threadRootId);
+            if (rootEvent) {
+                events.unshift(rootEvent);
+            }
+            thread = new Thread(events, this, this.client);
+            this.reEmitter.reEmit(thread, [ThreadEvent.Update, ThreadEvent.Ready]);
+            this.threads.set(thread.id, thread);
+            this.emit(ThreadEvent.New, thread);
        }
+        this.emit(ThreadEvent.Update, thread);
    }

    /**
@@ -1325,12 +1304,12 @@ export class Room extends EventEmitter {
     * @fires module:client~MatrixClient#event:"Room.timeline"
     * @private
     */
-    private addLiveEvent(event: MatrixEvent, duplicateStrategy?: "ignore" | "replace", fromCache = false): void {
+    private addLiveEvent(event: MatrixEvent, duplicateStrategy?: DuplicateStrategy, fromCache = false): void {
        if (event.isRedaction()) {
            const redactId = event.event.redacts;

            // if we know about this event, redact its contents now.
-            const redactedEvent = this.getUnfilteredTimelineSet().findEventById(redactId);
+            const redactedEvent = this.findEventById(redactId);
            if (redactedEvent) {
                redactedEvent.makeRedacted(event);

@@ -1411,6 +1390,13 @@ export class Room extends EventEmitter {
     * unique transaction id.
     */
    public addPendingEvent(event: MatrixEvent, txnId: string): void {
+        // TODO: Enable "pending events" for threads
+        // There's a fair few things to update to make them work with Threads
+        // Will get back to it when the plan is to build a more polished UI ready for production
+        if (this.client?.supportsExperimentalThreads() && event.threadRootId) {
+            return;
+        }
+
        if (event.status !== EventStatus.SENDING && event.status !== EventStatus.NOT_SENT) {
            throw new Error("addPendingEvent called on an event with status " +
                event.status);
@@ -1696,7 +1682,7 @@ export class Room extends EventEmitter {
     * @param {boolean} fromCache whether the sync response came from cache
     * @throws If <code>duplicateStrategy</code> is not falsey, 'replace' or 'ignore'.
     */
-    public addLiveEvents(events: MatrixEvent[], duplicateStrategy?: "replace" | "ignore", fromCache = false): void {
+    public addLiveEvents(events: MatrixEvent[], duplicateStrategy?: DuplicateStrategy, fromCache = false): void {
        let i;
        if (duplicateStrategy && ["replace", "ignore"].indexOf(duplicateStrategy) === -1) {
            throw new Error("duplicateStrategy MUST be either 'replace' or 'ignore'");
@@ -1723,6 +1709,10 @@ export class Room extends EventEmitter {
            // TODO: We should have a filter to say "only add state event
            // types X Y Z to the timeline".
            this.addLiveEvent(events[i], duplicateStrategy, fromCache);
+            const thread = this.threads.get(events[i].getId());
+            if (thread && !thread.ready) {
+                thread.addEvent(events[i], true);
+            }
        }
    }

@@ -2067,6 +2057,22 @@ export class Room extends EventEmitter {
        return this.currentState.getJoinRule();
    }

+    /**
+     * 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
+     */
+    public getHistoryVisibility(): HistoryVisibility {
+        return this.currentState.getHistoryVisibility();
+    }
+
+    /**
+     * 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
+     */
+    public getGuestAccess(): GuestAccess {
+        return this.currentState.getGuestAccess();
+    }
+
    /**
     * 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. Currently only RoomType.Space is known.
@@ -17,9 +17,16 @@ limitations under the License.
 import { EventEmitter } from "events";
 import { MatrixClient } from "../matrix";
 import { MatrixEvent } from "./event";
+import { EventTimeline } from "./event-timeline";
 import { EventTimelineSet } from './event-timeline-set';
 import { Room } from './room';

+export enum ThreadEvent {
+    New = "Thread.new",
+    Ready = "Thread.ready",
+    Update = "Thread.update",
+}
+
 /**
 * @experimental
 */
@@ -31,8 +38,7 @@ export class Thread extends EventEmitter {
    /**
     * A reference to all the events ID at the bottom of the threads
     */
-    public readonly tail = new Set<string>();
-    private _timelineSet: EventTimelineSet;
+    public readonly timelineSet: EventTimelineSet;

    constructor(
        events: MatrixEvent[] = [],
@@ -40,7 +46,7 @@ export class Thread extends EventEmitter {
        public readonly client: MatrixClient,
    ) {
        super();
-        this._timelineSet = new EventTimelineSet(room, {
+        this.timelineSet = new EventTimelineSet(room, {
            unstableClientRelationAggregation: true,
            timelineSupport: true,
        });
@@ -53,88 +59,60 @@ export class Thread extends EventEmitter {
     * Will fire "Thread.update"
     * @param event The event to add
     */
-    public async addEvent(event: MatrixEvent): Promise<void> {
-        if (this._timelineSet.findEventById(event.getId()) || event.status !== null) {
+    public async addEvent(event: MatrixEvent, toStartOfTimeline = false): Promise<void> {
+        if (this.timelineSet.findEventById(event.getId()) || event.status !== null) {
            return;
        }

-        if (this.tail.has(event.replyEventId)) {
-            this.tail.delete(event.replyEventId);
+        if (!this.root) {
+            if (event.isThreadRelation) {
+                this.root = event.threadRootId;
+            } else {
+                this.root = event.getId();
+            }
        }
-        this.tail.add(event.getId());

-        if (!event.replyEventId || !this._timelineSet.findEventById(event.replyEventId)) {
-            this.root = event.getId();
-        }
+        // all the relevant membership info to hydrate events with a sender
+        // is held in the main room timeline
+        // We want to fetch the room state from there and pass it down to this thread
+        // timeline set to let it reconcile an event with its relevant RoomMember
+        const roomState = this.room.getLiveTimeline().getState(EventTimeline.FORWARDS);

        event.setThread(this);
-        this._timelineSet.addLiveEvent(event);
+        this.timelineSet.addEventToTimeline(
+            event,
+            this.timelineSet.getLiveTimeline(),
+            toStartOfTimeline,
+            false,
+            roomState,
+        );

        if (this.ready) {
            this.client.decryptEventIfNeeded(event, {});
-            this.emit("Thread.update", this);
-        } else {
-            this.emit("Thread.update", this);
-        }
-    }
-
-    /**
-     * Completes the reply chain with all events
-     * missing from the current sync data
-     * Will fire "Thread.ready"
-     */
-    public async fetchReplyChain(): Promise<void> {
-        if (!this.ready) {
-            let mxEvent = this.room.findEventById(this.rootEvent.replyEventId);
-            if (!mxEvent) {
-                mxEvent = await this.fetchEventById(
-                    this.rootEvent.getRoomId(),
-                    this.rootEvent.replyEventId,
-                );
-            }
-
-            this.addEvent(mxEvent);
-            if (mxEvent.replyEventId) {
-                await this.fetchReplyChain();
-            } else {
-                await this.decryptEvents();
-                this.emit("Thread.ready", this);
-            }
        }
+        this.emit(ThreadEvent.Update, this);
    }

    private async decryptEvents(): Promise<void> {
        await Promise.allSettled(
-            Array.from(this._timelineSet.getLiveTimeline().getEvents()).map(event => {
+            Array.from(this.timelineSet.getLiveTimeline().getEvents()).map(event => {
                return this.client.decryptEventIfNeeded(event, {});
            }),
        );
    }

-    /**
-     * Fetches an event over the network
-     */
-    private async fetchEventById(roomId: string, eventId: string): Promise<MatrixEvent> {
-        const response = await this.client.http.authedRequest(
-            undefined,
-            "GET",
-            `/rooms/${roomId}/event/${eventId}`,
-        );
-        return new MatrixEvent(response);
-    }
-
    /**
     * Finds an event by ID in the current thread
     */
    public findEventById(eventId: string) {
-        return this._timelineSet.findEventById(eventId);
+        return this.timelineSet.findEventById(eventId);
    }

    /**
     * Determines thread's ready status
     */
    public get ready(): boolean {
-        return this.rootEvent.replyEventId === undefined;
+        return this.rootEvent !== undefined;
    }

    /**
@@ -151,6 +129,10 @@ export class Thread extends EventEmitter {
        return this.findEventById(this.root);
    }

+    public get roomId(): string {
+        return this.rootEvent.getRoomId();
+    }
+
    /**
     * The number of messages in the thread
     */
@@ -169,13 +151,6 @@ export class Thread extends EventEmitter {
        return participants;
    }

-    /**
-     * A read-only getter to access the timeline set
-     */
-    public get timelineSet(): EventTimelineSet {
-        return this._timelineSet;
-    }
-
    /**
     * A getter for the last event added to the thread
     */
@@ -185,7 +160,7 @@ export class Thread extends EventEmitter {
    }

    public get events(): MatrixEvent[] {
-        return this._timelineSet.getLiveTimeline().getEvents();
+        return this.timelineSet.getLiveTimeline().getEvents();
    }

    public merge(thread: Thread): void {
@@ -194,4 +169,33 @@ export class Thread extends EventEmitter {
        });
        this.events.forEach(event => event.setThread(this));
    }
+
+    public has(eventId: string): boolean {
+        return this.timelineSet.findEventById(eventId) instanceof MatrixEvent;
+    }
+
+    public on(event: ThreadEvent, listener: (...args: any[]) => void): this {
+        super.on(event, listener);
+        return this;
+    }
+
+    public once(event: ThreadEvent, listener: (...args: any[]) => void): this {
+        super.once(event, listener);
+        return this;
+    }
+
+    public off(event: ThreadEvent, listener: (...args: any[]) => void): this {
+        super.off(event, listener);
+        return this;
+    }
+
+    public addListener(event: ThreadEvent, listener: (...args: any[]) => void): this {
+        super.addListener(event, listener);
+        return this;
+    }
+
+    public removeListener(event: ThreadEvent, listener: (...args: any[]) => void): this {
+        super.removeListener(event, listener);
+        return this;
+    }
 }
@@ -31,17 +31,22 @@ import { logger } from './logger';
 const TIMER_CHECK_PERIOD_MS = 1000;

 // counter, for making up ids to return from setTimeout
-let _count = 0;
+let count = 0;

 // the key for our callback with the real global.setTimeout
-let _realCallbackKey;
+let realCallbackKey: NodeJS.Timeout | number;

 // a sorted list of the callbacks to be run.
 // each is an object with keys [runAt, func, params, key].
-const _callbackList = [];
+const callbackList: {
+    runAt: number;
+    func: (...params: any[]) => void;
+    params: any[];
+    key: number;
+}[] = [];

 // var debuglog = logger.log.bind(logger);
-const debuglog = function() {};
+const debuglog = function(...params: any[]) {};

 /**
 * Replace the function used by this module to get the current time.
@@ -52,10 +57,10 @@ const debuglog = function() {};
 *
 * @internal
 */
-export function setNow(f) {
-    _now = f || Date.now;
+export function setNow(f: () => number): void {
+    now = f || Date.now;
 }
-let _now = Date.now;
+let now = Date.now;

 /**
 * reimplementation of window.setTimeout, which will call the callback if
@@ -67,17 +72,16 @@ let _now = Date.now;
 * @return {Number} an identifier for this callback, which may be passed into
 *                   clearTimeout later.
 */
-export function setTimeout(func, delayMs) {
+export function setTimeout(func: (...params: any[]) => void, delayMs: number, ...params: any[]): number {
    delayMs = delayMs || 0;
    if (delayMs < 0) {
        delayMs = 0;
    }

-    const params = Array.prototype.slice.call(arguments, 2);
-    const runAt = _now() + delayMs;
-    const key = _count++;
+    const runAt = now() + delayMs;
+    const key = count++;
    debuglog("setTimeout: scheduling cb", key, "at", runAt,
-             "(delay", delayMs, ")");
+        "(delay", delayMs, ")");
    const data = {
        runAt: runAt,
        func: func,
@@ -87,13 +91,13 @@ export function setTimeout(func, delayMs) {

    // figure out where it goes in the list
    const idx = binarySearch(
-        _callbackList, function(el) {
+        callbackList, function(el) {
            return el.runAt - runAt;
        },
    );

-    _callbackList.splice(idx, 0, data);
-    _scheduleRealCallback();
+    callbackList.splice(idx, 0, data);
+    scheduleRealCallback();

    return key;
 }
@@ -103,68 +107,69 @@ export function setTimeout(func, delayMs) {
 *
 * @param {Number} key   result from an earlier setTimeout call
 */
-export function clearTimeout(key) {
-    if (_callbackList.length === 0) {
+export function clearTimeout(key: number): void {
+    if (callbackList.length === 0) {
        return;
    }

    // remove the element from the list
    let i;
-    for (i = 0; i < _callbackList.length; i++) {
-        const cb = _callbackList[i];
+    for (i = 0; i < callbackList.length; i++) {
+        const cb = callbackList[i];
        if (cb.key == key) {
-            _callbackList.splice(i, 1);
+            callbackList.splice(i, 1);
            break;
        }
    }

    // iff it was the first one in the list, reschedule our callback.
    if (i === 0) {
-        _scheduleRealCallback();
+        scheduleRealCallback();
    }
 }

-// use the real global.setTimeout to schedule a callback to _runCallbacks.
-function _scheduleRealCallback() {
-    if (_realCallbackKey) {
-        global.clearTimeout(_realCallbackKey);
+// use the real global.setTimeout to schedule a callback to runCallbacks.
+function scheduleRealCallback(): void {
+    if (realCallbackKey) {
+        global.clearTimeout(realCallbackKey as NodeJS.Timeout);
    }

-    const first = _callbackList[0];
+    const first = callbackList[0];

    if (!first) {
-        debuglog("_scheduleRealCallback: no more callbacks, not rescheduling");
+        debuglog("scheduleRealCallback: no more callbacks, not rescheduling");
        return;
    }

-    const now = _now();
-    const delayMs = Math.min(first.runAt - now, TIMER_CHECK_PERIOD_MS);
+    const timestamp = now();
+    const delayMs = Math.min(first.runAt - timestamp, TIMER_CHECK_PERIOD_MS);

-    debuglog("_scheduleRealCallback: now:", now, "delay:", delayMs);
-    _realCallbackKey = global.setTimeout(_runCallbacks, delayMs);
+    debuglog("scheduleRealCallback: now:", timestamp, "delay:", delayMs);
+    realCallbackKey = global.setTimeout(runCallbacks, delayMs);
 }

-function _runCallbacks() {
+function runCallbacks(): void {
    let cb;
-    const now = _now();
-    debuglog("_runCallbacks: now:", now);
+    const timestamp = now();
+    debuglog("runCallbacks: now:", timestamp);

    // get the list of things to call
    const callbacksToRun = [];
+    // eslint-disable-next-line
    while (true) {
-        const first = _callbackList[0];
-        if (!first || first.runAt > now) {
+        const first = callbackList[0];
+        if (!first || first.runAt > timestamp) {
            break;
        }
-        cb = _callbackList.shift();
-        debuglog("_runCallbacks: popping", cb.key);
+        cb = callbackList.shift();
+        debuglog("runCallbacks: popping", cb.key);
        callbacksToRun.push(cb);
    }

    // reschedule the real callback before running our functions, to
    // keep the codepaths the same whether or not our functions
    // register their own setTimeouts.
-    _scheduleRealCallback();
+    scheduleRealCallback();

    for (let i = 0; i < callbacksToRun.length; i++) {
        cb = callbacksToRun[i];
@@ -172,7 +177,7 @@ function _runCallbacks() {
            cb.func.apply(global, cb.params);
        } catch (e) {
            logger.error("Uncaught exception in callback function",
-                          e.stack || e);
+                e.stack || e);
        }
    }
 }
@@ -182,7 +187,7 @@ function _runCallbacks() {
 * returns the index of the last element for which func returns
 * greater than zero, or array.length if no such element exists.
 */
-function binarySearch(array, func) {
+function binarySearch<T>(array: T[], func: (v: T) => number): number {
    // min is inclusive, max exclusive.
    let min = 0;
    let max = array.length;
@@ -47,7 +47,7 @@ export class RoomHierarchy {
     * @constructor
     */
    constructor(
-        private readonly root: Room,
+        public readonly root: Room,
        private readonly pageSize?: number,
        private readonly maxDepth?: number,
        private readonly suggestedOnly = false,
@@ -61,6 +61,10 @@ export class RoomHierarchy {
        return !!this.serverSupportError || !!this.nextBatch || !this._rooms;
    }

+    public get loading(): boolean {
+        return !!this.loadRequest;
+    }
+
    public get rooms(): IHierarchyRoom[] {
        return this._rooms;
    }
@@ -315,7 +315,19 @@ export class SyncApi {
    public partitionThreadedEvents(events: MatrixEvent[]): [MatrixEvent[], MatrixEvent[]] {
        if (this.opts.experimentalThreadSupport) {
            return events.reduce((memo, event: MatrixEvent) => {
-                memo[event.replyInThread ? 1 : 0].push(event);
+                const room = this.client.getRoom(event.getRoomId());
+                // An event should live in the thread timeline if
+                // - It's a reply in thread event
+                // - It's related to a reply in thread event
+                let shouldLiveInThreadTimeline = event.isThreadRelation;
+                if (!shouldLiveInThreadTimeline) {
+                    const parentEventId = event.parentEventId;
+                    const parentEvent = room?.findEventById(parentEventId) || events.find((mxEv: MatrixEvent) => {
+                        return mxEv.getId() === parentEventId;
+                    });
+                    shouldLiveInThreadTimeline = parentEvent?.isThreadRelation;
+                }
+                memo[shouldLiveInThreadTimeline ? 1 : 0].push(event);
                return memo;
            }, [[], []]);
        } else {
@@ -704,7 +716,11 @@ export class SyncApi {
     */
    public stop(): void {
        debuglog("SyncApi.stop");
-        if (global.window) {
+        // It is necessary to check for the existance of
+        // global.window AND global.window.removeEventListener.
+        // Some platforms (e.g. React Native) register global.window,
+        // but do not have global.window.removeEventListener.
+        if (global.window && global.window.removeEventListener) {
            global.window.removeEventListener("online", this.onOnline, false);
        }
        this.running = false;
@@ -128,7 +128,9 @@ export enum CallEvent {

    AssertedIdentityChanged = 'asserted_identity_changed',

-    LengthChanged = 'length_changed'
+    LengthChanged = 'length_changed',
+
+    DataChannel = 'datachannel',
 }

 export enum CallErrorCode {
@@ -212,11 +214,6 @@ export enum CallErrorCode {
    Transfered = 'transferred',
 }

-enum ConstraintsType {
-    Audio = "audio",
-    Video = "video",
-}
-
 /**
 * The version field that we set in m.call.* events
 */
@@ -228,21 +225,6 @@ const FALLBACK_ICE_SERVER = 'stun:turn.matrix.org';
 /** The length of time a call can be ringing for. */
 const CALL_TIMEOUT_MS = 60000;

-/** Retrieves sources from desktopCapturer */
-export function getDesktopCapturerSources(): Promise<Array<DesktopCapturerSource>> {
-    const options: GetSourcesOptions = {
-        thumbnailSize: {
-            height: 176,
-            width: 312,
-        },
-        types: [
-            "screen",
-            "window",
-        ],
-    };
-    return window.electron.getDesktopCapturerSources(options);
-}
-
 export class CallError extends Error {
    code: string;

@@ -271,7 +253,6 @@ function genCallID(): string {
 */
 export class MatrixCall extends EventEmitter {
    public roomId: string;
-    public type: CallType = null;
    public callId: string;
    public state = CallState.Fledgling;
    public hangupParty: CallParty;
@@ -352,11 +333,7 @@ export class MatrixCall extends EventEmitter {
     * @throws If you have not specified a listener for 'error' events.
     */
    public async placeVoiceCall(): Promise<void> {
-        logger.debug("placeVoiceCall");
-        this.checkForErrorListener();
-        const constraints = getUserMediaContraints(ConstraintsType.Audio);
-        this.type = CallType.Voice;
-        await this.placeCallWithConstraints(constraints);
+        await this.placeCall(true, false);
    }

    /**
@@ -364,11 +341,19 @@ export class MatrixCall extends EventEmitter {
     * @throws If you have not specified a listener for 'error' events.
     */
    public async placeVideoCall(): Promise<void> {
-        logger.debug("placeVideoCall");
-        this.checkForErrorListener();
-        const constraints = getUserMediaContraints(ConstraintsType.Video);
-        this.type = CallType.Video;
-        await this.placeCallWithConstraints(constraints);
+        await this.placeCall(true, true);
+    }
+
+    /**
+     * 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.
+     */
+    public createDataChannel(label: string, options: RTCDataChannelInit) {
+        const dataChannel = this.peerConn.createDataChannel(label, options);
+        this.emit(CallEvent.DataChannel, dataChannel);
+        logger.debug("created data channel");
+        return dataChannel;
    }

    public getOpponentMember(): RoomMember {
@@ -387,6 +372,38 @@ export class MatrixCall extends EventEmitter {
        return this.remoteAssertedIdentity;
    }

+    public get type(): CallType {
+        return (this.hasLocalUserMediaVideoTrack || this.hasRemoteUserMediaVideoTrack)
+            ? CallType.Video
+            : CallType.Voice;
+    }
+
+    public get hasLocalUserMediaVideoTrack(): boolean {
+        return this.localUsermediaStream?.getVideoTracks().length > 0;
+    }
+
+    public get hasRemoteUserMediaVideoTrack(): boolean {
+        return this.getRemoteFeeds().some((feed) => {
+            return (
+                feed.purpose === SDPStreamMetadataPurpose.Usermedia &&
+                feed.stream.getVideoTracks().length > 0
+            );
+        });
+    }
+
+    public get hasLocalUserMediaAudioTrack(): boolean {
+        return this.localUsermediaStream?.getAudioTracks().length > 0;
+    }
+
+    public get hasRemoteUserMediaAudioTrack(): boolean {
+        return this.getRemoteFeeds().some((feed) => {
+            return (
+                feed.purpose === SDPStreamMetadataPurpose.Usermedia &&
+                feed.stream.getAudioTracks().length > 0
+            );
+        });
+    }
+
    public get localUsermediaFeed(): CallFeed {
        return this.getLocalFeeds().find((feed) => feed.purpose === SDPStreamMetadataPurpose.Usermedia);
    }
@@ -480,7 +497,15 @@ export class MatrixCall extends EventEmitter {
        if (existingFeed) {
            existingFeed.setNewStream(stream);
        } else {
-            this.feeds.push(new CallFeed(stream, userId, purpose, this.client, this.roomId, audioMuted, videoMuted));
+            this.feeds.push(new CallFeed({
+                client: this.client,
+                roomId: this.roomId,
+                userId,
+                stream,
+                purpose,
+                audioMuted,
+                videoMuted,
+            }));
            this.emit(CallEvent.FeedsChanged, this.feeds);
        }

@@ -511,7 +536,15 @@ export class MatrixCall extends EventEmitter {
        if (feed) {
            feed.setNewStream(stream);
        } else {
-            this.feeds.push(new CallFeed(stream, userId, purpose, this.client, this.roomId, false, false));
+            this.feeds.push(new CallFeed({
+                client: this.client,
+                roomId: this.roomId,
+                audioMuted: false,
+                videoMuted: false,
+                userId,
+                stream,
+                purpose,
+            }));
            this.emit(CallEvent.FeedsChanged, this.feeds);
        }

@@ -526,7 +559,15 @@ export class MatrixCall extends EventEmitter {
        if (existingFeed) {
            existingFeed.setNewStream(stream);
        } else {
-            this.feeds.push(new CallFeed(stream, userId, purpose, this.client, this.roomId, false, false));
+            this.feeds.push(new CallFeed({
+                client: this.client,
+                roomId: this.roomId,
+                audioMuted: stream.getAudioTracks().length === 0,
+                videoMuted: stream.getVideoTracks().length === 0,
+                userId,
+                stream,
+                purpose,
+            }));
            this.emit(CallEvent.FeedsChanged, this.feeds);
        }

@@ -558,6 +599,10 @@ export class MatrixCall extends EventEmitter {
    }

    private deleteAllFeeds(): void {
+        for (const feed of this.feeds) {
+            feed.dispose();
+        }
+
        this.feeds = [];
        this.emit(CallEvent.FeedsChanged, this.feeds);
    }
@@ -571,6 +616,7 @@ export class MatrixCall extends EventEmitter {
            return;
        }

+        feed.dispose();
        this.feeds.splice(this.feeds.indexOf(feed), 1);
        this.emit(CallEvent.FeedsChanged, this.feeds);
    }
@@ -645,8 +691,6 @@ export class MatrixCall extends EventEmitter {
            return;
        }

-        this.type = remoteStream.getTracks().some(t => t.kind === 'video') ? CallType.Video : CallType.Voice;
-
        this.setState(CallState.Ringing);

        if (event.getLocalAge()) {
@@ -676,33 +720,62 @@ export class MatrixCall extends EventEmitter {
        this.setState(CallState.Ended);
    }

+    private shouldAnswerWithMediaType(
+        wantedValue: boolean | undefined, valueOfTheOtherSide: boolean | undefined, type: "audio" | "video",
+    ): boolean {
+        if (wantedValue && !valueOfTheOtherSide) {
+            // TODO: Figure out how to do this
+            logger.warn(`Unable to answer with ${type} because the other side isn't sending it either.`);
+            return false;
+        } else if (
+            !utils.isNullOrUndefined(wantedValue) &&
+            wantedValue !== valueOfTheOtherSide &&
+            !this.opponentSupportsSDPStreamMetadata()
+        ) {
+            logger.warn(
+                `Unable to answer with ${type}=${wantedValue} because the other side doesn't support it. ` +
+                `Answering with ${type}=${valueOfTheOtherSide}.`,
+            );
+            return valueOfTheOtherSide;
+        }
+        return wantedValue ?? valueOfTheOtherSide;
+    }
+
    /**
     * Answer a call.
     */
-    public async answer(): Promise<void> {
-        if (this.inviteOrAnswerSent) {
-            return;
-        }
+    public async answer(audio?: boolean, video?: boolean): Promise<void> {
+        if (this.inviteOrAnswerSent) return;
+        // TODO: Figure out how to do this
+        if (audio === false && video === false) throw new Error("You CANNOT answer a call without media");

-        logger.debug(`Answering call ${this.callId} of type ${this.type}`);
+        logger.debug(`Answering call ${this.callId}`);

        if (!this.localUsermediaStream && !this.waitForLocalAVStream) {
-            const constraints = getUserMediaContraints(
-                this.type == CallType.Video ?
-                    ConstraintsType.Video:
-                    ConstraintsType.Audio,
-            );
-            logger.log("Getting user media with constraints", constraints);
+            const prevState = this.state;
+            const answerWithAudio = this.shouldAnswerWithMediaType(audio, this.hasRemoteUserMediaAudioTrack, "audio");
+            const answerWithVideo = this.shouldAnswerWithMediaType(video, this.hasRemoteUserMediaVideoTrack, "video");
+
            this.setState(CallState.WaitLocalMedia);
            this.waitForLocalAVStream = true;

            try {
-                const mediaStream = await navigator.mediaDevices.getUserMedia(constraints);
+                const mediaStream = await this.client.getMediaHandler().getUserMediaStream(
+                    answerWithAudio, answerWithVideo,
+                );
                this.waitForLocalAVStream = false;
                this.gotUserMediaForAnswer(mediaStream);
            } catch (e) {
-                this.getUserMediaFailed(e);
-                return;
+                if (answerWithVideo) {
+                    // Try to answer without video
+                    logger.warn("Failed to getUserMedia(), trying to getUserMedia() without video");
+                    this.setState(prevState);
+                    this.waitForLocalAVStream = false;
+                    await this.answer(answerWithAudio, false);
+                } else {
+                    this.getUserMediaFailed(e);
+                    return;
+                }
            }
        } else if (this.waitForLocalAVStream) {
            this.setState(CallState.WaitLocalMedia);
@@ -770,6 +843,50 @@ export class MatrixCall extends EventEmitter {
        this.sendVoipEvent(EventType.CallReject, {});
    }

+    /**
+     * 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
+     */
+    private async upgradeCall(
+        audio: boolean, video: boolean,
+    ): Promise<void> {
+        // We don't do call downgrades
+        if (!audio && !video) return;
+        if (!this.opponentSupportsSDPStreamMetadata()) return;
+
+        try {
+            const upgradeAudio = audio && !this.hasLocalUserMediaAudioTrack;
+            const upgradeVideo = video && !this.hasLocalUserMediaVideoTrack;
+            logger.debug(`Upgrading call: audio?=${upgradeAudio} video?=${upgradeVideo}`);
+
+            const stream = await this.client.getMediaHandler().getUserMediaStream(upgradeAudio, upgradeVideo);
+            if (upgradeAudio && upgradeVideo) {
+                if (this.hasLocalUserMediaAudioTrack) return;
+                if (this.hasLocalUserMediaVideoTrack) return;
+
+                this.pushLocalFeed(stream, SDPStreamMetadataPurpose.Usermedia);
+            } else if (upgradeAudio) {
+                if (this.hasLocalUserMediaAudioTrack) return;
+
+                const audioTrack = stream.getAudioTracks()[0];
+                this.localUsermediaStream.addTrack(audioTrack);
+                this.peerConn.addTrack(audioTrack, this.localUsermediaStream);
+            } else if (upgradeVideo) {
+                if (this.hasLocalUserMediaVideoTrack) return;
+
+                const videoTrack = stream.getVideoTracks()[0];
+                this.localUsermediaStream.addTrack(videoTrack);
+                this.peerConn.addTrack(videoTrack, this.localUsermediaStream);
+            }
+        } catch (error) {
+            logger.error("Failed to upgrade the call", error);
+            this.emit(CallEvent.Error,
+                new CallError(CallErrorCode.NoUserMedia, "Failed to get camera access: ", error),
+            );
+        }
+    }
+
    /**
     * Returns true if this.remoteSDPStreamMetadata is defined, otherwise returns false
     * @returns {boolean} can screenshare
@@ -789,12 +906,11 @@ export class MatrixCall extends EventEmitter {
    /**
     * Starts/stops screensharing
     * @param enabled the desired screensharing state
-     * @param selectDesktopCapturerSource callBack to select a screensharing stream on desktop
+     * @param {string} desktopCapturerSourceId optional id of the desktop capturer source to use
     * @returns {boolean} new screensharing state
     */
    public async setScreensharingEnabled(
-        enabled: boolean,
-        selectDesktopCapturerSource?: () => Promise<DesktopCapturerSource>,
+        enabled: boolean, desktopCapturerSourceId?: string,
    ): Promise<boolean> {
        // Skip if there is nothing to do
        if (enabled && this.isScreensharing()) {
@@ -807,13 +923,13 @@ export class MatrixCall extends EventEmitter {

        // Fallback to replaceTrack()
        if (!this.opponentSupportsSDPStreamMetadata()) {
-            return await this.setScreensharingEnabledWithoutMetadataSupport(enabled, selectDesktopCapturerSource);
+            return await this.setScreensharingEnabledWithoutMetadataSupport(enabled, desktopCapturerSourceId);
        }

        logger.debug(`Set screensharing enabled? ${enabled}`);
        if (enabled) {
            try {
-                const stream = await getScreensharingStream(selectDesktopCapturerSource);
+                const stream = await this.client.getMediaHandler().getScreensharingStream(desktopCapturerSourceId);
                if (!stream) return false;
                this.pushLocalFeed(stream, SDPStreamMetadataPurpose.Screenshare);
                return true;
@@ -827,9 +943,7 @@ export class MatrixCall extends EventEmitter {
            for (const sender of this.screensharingSenders) {
                this.peerConn.removeTrack(sender);
            }
-            for (const track of this.localScreensharingStream.getTracks()) {
-                track.stop();
-            }
+            this.client.getMediaHandler().stopScreensharingStream(this.localScreensharingStream);
            this.deleteFeedByStream(this.localScreensharingStream);
            return false;
        }
@@ -839,17 +953,16 @@ export class MatrixCall extends EventEmitter {
     * Starts/stops screensharing
     * Should be used ONLY if the opponent doesn't support SDPStreamMetadata
     * @param enabled the desired screensharing state
-     * @param selectDesktopCapturerSource callBack to select a screensharing stream on desktop
+     * @param {string} desktopCapturerSourceId optional id of the desktop capturer source to use
     * @returns {boolean} new screensharing state
     */
    private async setScreensharingEnabledWithoutMetadataSupport(
-        enabled: boolean,
-        selectDesktopCapturerSource?: () => Promise<DesktopCapturerSource>,
+        enabled: boolean, desktopCapturerSourceId?: string,
    ): Promise<boolean> {
        logger.debug(`Set screensharing enabled? ${enabled} using replaceTrack()`);
        if (enabled) {
            try {
-                const stream = await getScreensharingStream(selectDesktopCapturerSource);
+                const stream = await this.client.getMediaHandler().getScreensharingStream(desktopCapturerSourceId);
                if (!stream) return false;

                const track = stream.getTracks().find((track) => {
@@ -878,9 +991,7 @@ export class MatrixCall extends EventEmitter {
            });
            sender.replaceTrack(track);

-            for (const track of this.localScreensharingStream.getTracks()) {
-                track.stop();
-            }
+            this.client.getMediaHandler().stopScreensharingStream(this.localScreensharingStream);
            this.deleteFeedByStream(this.localScreensharingStream);

            return false;
@@ -890,10 +1001,20 @@ export class MatrixCall extends EventEmitter {
    /**
     * Set whether our outbound video should be muted or not.
     * @param {boolean} muted True to mute the outbound video.
+     * @returns the new mute state
     */
-    public setLocalVideoMuted(muted: boolean): void {
+    public async setLocalVideoMuted(muted: boolean): Promise<boolean> {
+        if (!await this.client.getMediaHandler().hasVideoDevice()) {
+            return this.isLocalVideoMuted();
+        }
+
+        if (!this.hasLocalUserMediaVideoTrack && !muted) {
+            await this.upgradeCall(false, true);
+            return this.isLocalVideoMuted();
+        }
        this.localUsermediaFeed?.setVideoMuted(muted);
        this.updateMuteStatus();
+        return this.isLocalVideoMuted();
    }

    /**
@@ -912,10 +1033,20 @@ export class MatrixCall extends EventEmitter {
    /**
     * Set whether the microphone should be muted or not.
     * @param {boolean} muted True to mute the mic.
+     * @returns the new mute state
     */
-    public setMicrophoneMuted(muted: boolean): void {
+    public async setMicrophoneMuted(muted: boolean): Promise<boolean> {
+        if (!await this.client.getMediaHandler().hasAudioDevice()) {
+            return this.isMicrophoneMuted();
+        }
+
+        if (!this.hasLocalUserMediaAudioTrack && !muted) {
+            await this.upgradeCall(true, false);
+            return this.isMicrophoneMuted();
+        }
        this.localUsermediaFeed?.setAudioMuted(muted);
        this.updateMuteStatus();
+        return this.isMicrophoneMuted();
    }

    /**
@@ -1019,7 +1150,7 @@ export class MatrixCall extends EventEmitter {
        this.pushLocalFeed(stream, SDPStreamMetadataPurpose.Usermedia);
        this.setState(CallState.CreateOffer);

-        logger.debug("gotUserMediaForInvite -> " + this.type);
+        logger.debug("gotUserMediaForInvite");
        // Now we wait for the negotiationneeded event
    };

@@ -1484,10 +1615,13 @@ export class MatrixCall extends EventEmitter {
        // chrome doesn't implement any of the 'onstarted' events yet
        if (this.peerConn.iceConnectionState == 'connected') {
            this.setState(CallState.Connected);
-            this.callLengthInterval = setInterval(() => {
-                this.callLength++;
-                this.emit(CallEvent.LengthChanged, this.callLength);
-            }, 1000);
+
+            if (!this.callLengthInterval) {
+                this.callLengthInterval = setInterval(() => {
+                    this.callLength++;
+                    this.emit(CallEvent.LengthChanged, this.callLength);
+                }, 1000);
+            }
        } else if (this.peerConn.iceConnectionState == 'failed') {
            this.hangup(CallErrorCode.IceFailed, false);
        }
@@ -1511,6 +1645,10 @@ export class MatrixCall extends EventEmitter {
        stream.addEventListener("removetrack", () => this.deleteFeedByStream(stream));
    };

+    private onDataChannel = (ev: RTCDataChannelEvent): void => {
+        this.emit(CallEvent.DataChannel, ev.channel);
+    };
+
    /**
     * This method removes all video/rtx codecs from screensharing video
     * transceivers. This is necessary since they can cause problems. Without
@@ -1763,8 +1901,14 @@ export class MatrixCall extends EventEmitter {
        logger.debug(`stopAllMedia (stream=${this.localUsermediaStream})`);

        for (const feed of this.feeds) {
-            for (const track of feed.stream.getTracks()) {
-                track.stop();
+            if (feed.isLocal() && feed.purpose === SDPStreamMetadataPurpose.Usermedia) {
+                this.client.getMediaHandler().stopUserMediaStream(feed.stream);
+            } else if (feed.isLocal() && feed.purpose === SDPStreamMetadataPurpose.Screenshare) {
+                this.client.getMediaHandler().stopScreensharingStream(feed.stream);
+            } else {
+                for (const track of feed.stream.getTracks()) {
+                    track.stop();
+                }
            }
        }
    }
@@ -1826,8 +1970,17 @@ export class MatrixCall extends EventEmitter {
        }
    }

-    private async placeCallWithConstraints(constraints: MediaStreamConstraints): Promise<void> {
-        logger.log("Getting user media with constraints", constraints);
+    /**
+     * Place a call to this room.
+     * @throws if you have not specified a listener for 'error' events.
+     * @throws if have passed audio=false.
+     */
+    public async placeCall(audio: boolean, video: boolean): Promise<void> {
+        logger.debug(`placeCall audio=${audio} video=${video}`);
+        if (!audio) {
+            throw new Error("You CANNOT start a call without audio");
+        }
+        this.checkForErrorListener();
        // XXX Find a better way to do this
        this.client.callEventHandler.calls.set(this.callId, this);
        this.setState(CallState.WaitLocalMedia);
@@ -1845,7 +1998,7 @@ export class MatrixCall extends EventEmitter {
        this.peerConn = this.createPeerConnection();

        try {
-            const mediaStream = await navigator.mediaDevices.getUserMedia(constraints);
+            const mediaStream = await this.client.getMediaHandler().getUserMediaStream(audio, video);
            this.gotUserMediaForInvite(mediaStream);
        } catch (e) {
            this.getUserMediaFailed(e);
@@ -1867,6 +2020,7 @@ export class MatrixCall extends EventEmitter {
        pc.addEventListener('icegatheringstatechange', this.onIceGatheringStateChange);
        pc.addEventListener('track', this.onTrack);
        pc.addEventListener('negotiationneeded', this.onNegotiationNeeded);
+        pc.addEventListener('datachannel', this.onDataChannel);

        return pc;
    }
@@ -1939,105 +2093,12 @@ export class MatrixCall extends EventEmitter {
    }
 }

-async function getScreensharingStream(
-    selectDesktopCapturerSource?: () => Promise<DesktopCapturerSource>,
-): Promise<MediaStream> {
-    const screenshareConstraints = await getScreenshareContraints(selectDesktopCapturerSource);
-    if (!screenshareConstraints) return null;
-
-    if (window.electron?.getDesktopCapturerSources) {
-        // We are using Electron
-        logger.debug("Getting screen stream using getUserMedia()...");
-        return await navigator.mediaDevices.getUserMedia(screenshareConstraints);
-    } else {
-        // We are not using Electron
-        logger.debug("Getting screen stream using getDisplayMedia()...");
-        return await navigator.mediaDevices.getDisplayMedia(screenshareConstraints);
-    }
-}
-
 function setTracksEnabled(tracks: Array<MediaStreamTrack>, enabled: boolean): void {
    for (let i = 0; i < tracks.length; i++) {
        tracks[i].enabled = enabled;
    }
 }

-function getUserMediaContraints(type: ConstraintsType): MediaStreamConstraints {
-    const isWebkit = !!navigator.webkitGetUserMedia;
-
-    switch (type) {
-        case ConstraintsType.Audio: {
-            return {
-                audio: {
-                    deviceId: audioInput ? { ideal: audioInput } : undefined,
-                },
-                video: false,
-            };
-        }
-        case ConstraintsType.Video: {
-            return {
-                audio: {
-                    deviceId: audioInput ? { ideal: audioInput } : undefined,
-                }, video: {
-                    deviceId: videoInput ? { ideal: 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 },
-                },
-            };
-        }
-    }
-}
-
-async function getScreenshareContraints(
-    selectDesktopCapturerSource?: () => Promise<DesktopCapturerSource>,
-): Promise<DesktopCapturerConstraints> {
-    if (window.electron?.getDesktopCapturerSources && selectDesktopCapturerSource) {
-        // We have access to getDesktopCapturerSources()
-        logger.debug("Electron getDesktopCapturerSources() is available...");
-        const selectedSource = await selectDesktopCapturerSource();
-        if (!selectedSource) return null;
-        return {
-            audio: false,
-            video: {
-                mandatory: {
-                    chromeMediaSource: "desktop",
-                    chromeMediaSourceId: selectedSource.id,
-                },
-            },
-        };
-    } else {
-        // We do not have access to the Electron desktop capturer,
-        // therefore we can assume we are on the web
-        logger.debug("Electron desktopCapturer is not available...");
-        return {
-            audio: false,
-            video: true,
-        };
-    }
-}
-
-let audioInput: string;
-let videoInput: string;
-/**
- * Set an audio input device to use for MatrixCalls
- * @function
- * @param {string=} deviceId the identifier for the device
- * undefined treated as unset
- */
-export function setAudioInput(deviceId: string): void { audioInput = deviceId; }
-/**
- * Set a video input device to use for MatrixCalls
- * @function
- * @param {string=} deviceId the identifier for the device
- * undefined treated as unset
- */
-export function setVideoInput(deviceId: string): void { videoInput = deviceId; }
-
 /**
 * DEPRECATED
 * Use client.createCall()
@@ -22,6 +22,16 @@ import { RoomMember } from "../models/room-member";
 const POLLING_INTERVAL = 250; // ms
 const SPEAKING_THRESHOLD = -60; // dB

+export interface ICallFeedOpts {
+    client: MatrixClient;
+    roomId: string;
+    userId: string;
+    stream: MediaStream;
+    purpose: SDPStreamMetadataPurpose;
+    audioMuted: boolean;
+    videoMuted: boolean;
+}
+
 export enum CallFeedEvent {
    NewStream = "new_stream",
    MuteStateChanged = "mute_state_changed",
@@ -30,24 +40,34 @@ export enum CallFeedEvent {
 }

 export class CallFeed extends EventEmitter {
+    public stream: MediaStream;
+    public userId: string;
+    public purpose: SDPStreamMetadataPurpose;
+
+    private client: MatrixClient;
+    private roomId: string;
+    private audioMuted: boolean;
+    private videoMuted: boolean;
    private measuringVolumeActivity = false;
    private audioContext: AudioContext;
    private analyser: AnalyserNode;
    private frequencyBinCount: Float32Array;
    private speakingThreshold = SPEAKING_THRESHOLD;
    private speaking = false;
+    private volumeLooperTimeout: number;

-    constructor(
-        public stream: MediaStream,
-        public userId: string,
-        public purpose: SDPStreamMetadataPurpose,
-        private client: MatrixClient,
-        private roomId: string,
-        private audioMuted: boolean,
-        private videoMuted: boolean,
-    ) {
+    constructor(opts: ICallFeedOpts) {
        super();

+        this.client = opts.client;
+        this.roomId = opts.roomId;
+        this.userId = opts.userId;
+        this.purpose = opts.purpose;
+        this.audioMuted = opts.audioMuted;
+        this.videoMuted = opts.videoMuted;
+
+        this.updateStream(null, opts.stream);
+
        if (this.hasAudioTrack) {
            this.initVolumeMeasuring();
        }
@@ -57,6 +77,25 @@ export class CallFeed extends EventEmitter {
        return this.stream.getAudioTracks().length > 0;
    }

+    private updateStream(oldStream: MediaStream, newStream: MediaStream): void {
+        if (oldStream) {
+            oldStream.removeEventListener("addtrack", this.onAddTrack);
+            this.measureVolumeActivity(false);
+        }
+        if (newStream) {
+            this.stream = newStream;
+            newStream.addEventListener("addtrack", this.onAddTrack);
+
+            if (this.hasAudioTrack) {
+                this.initVolumeMeasuring();
+            } else {
+                this.measureVolumeActivity(false);
+            }
+        }
+
+        this.emit(CallFeedEvent.NewStream, this.stream);
+    }
+
    private initVolumeMeasuring(): void {
        const AudioContext = window.AudioContext || window.webkitAudioContext;
        if (!this.hasAudioTrack || !AudioContext) return;
@@ -73,6 +112,10 @@ export class CallFeed extends EventEmitter {
        this.frequencyBinCount = new Float32Array(this.analyser.frequencyBinCount);
    }

+    private onAddTrack = (): void => {
+        this.emit(CallFeedEvent.NewStream, this.stream);
+    };
+
    /**
     * Returns callRoom member
     * @returns member of the callRoom
@@ -115,14 +158,7 @@ export class CallFeed extends EventEmitter {
     * @param newStream new stream with which to replace the current one
     */
    public setNewStream(newStream: MediaStream): void {
-        this.stream = newStream;
-        this.emit(CallFeedEvent.NewStream, this.stream);
-
-        if (this.hasAudioTrack) {
-            this.initVolumeMeasuring();
-        } else {
-            this.measureVolumeActivity(false);
-        }
+        this.updateStream(this.stream, newStream);
    }

    /**
@@ -166,7 +202,7 @@ export class CallFeed extends EventEmitter {
    private volumeLooper(): void {
        if (!this.analyser) return;

-        setTimeout(() => {
+        this.volumeLooperTimeout = setTimeout(() => {
            if (!this.measuringVolumeActivity) return;

            this.analyser.getFloatFrequencyData(this.frequencyBinCount);
@@ -188,4 +224,8 @@ export class CallFeed extends EventEmitter {
            this.volumeLooper();
        }, POLLING_INTERVAL);
    }
+
+    public dispose(): void {
+        clearTimeout(this.volumeLooperTimeout);
+    }
 }
@@ -0,0 +1,214 @@
+/*
+Copyright 2015, 2016 OpenMarket Ltd
+Copyright 2017 New Vector Ltd
+Copyright 2019, 2020 The Matrix.org Foundation C.I.C.
+Copyright 2021 Šimon Brandner <simon.bra.ag@gmail.com>
+
+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 { logger } from "../logger";
+
+export class MediaHandler {
+    private audioInput: string;
+    private videoInput: string;
+    private userMediaStreams: MediaStream[] = [];
+    private screensharingStreams: MediaStream[] = [];
+
+    /**
+     * Set an audio input device to use for MatrixCalls
+     * @param {string} deviceId the identifier for the device
+     * undefined treated as unset
+     */
+    public setAudioInput(deviceId: string): void {
+        this.audioInput = deviceId;
+    }
+
+    /**
+     * Set a video input device to use for MatrixCalls
+     * @param {string} deviceId the identifier for the device
+     * undefined treated as unset
+     */
+    public setVideoInput(deviceId: string): void {
+        this.videoInput = deviceId;
+    }
+
+    public async hasAudioDevice(): Promise<boolean> {
+        const devices = await navigator.mediaDevices.enumerateDevices();
+        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;
+    }
+
+    /**
+     * @returns {MediaStream} based on passed parameters
+     */
+    public async getUserMediaStream(audio: boolean, video: boolean): Promise<MediaStream> {
+        const shouldRequestAudio = audio && await this.hasAudioDevice();
+        const shouldRequestVideo = video && await this.hasVideoDevice();
+
+        let stream: MediaStream;
+
+        // Find a stream with matching tracks
+        const matchingStream = this.userMediaStreams.find((stream) => {
+            if (shouldRequestAudio !== (stream.getAudioTracks().length > 0)) return false;
+            if (shouldRequestVideo !== (stream.getVideoTracks().length > 0)) return false;
+            return true;
+        });
+
+        if (matchingStream) {
+            logger.log("Cloning user media stream", matchingStream.id);
+            stream = matchingStream.clone();
+        } else {
+            const constraints = this.getUserMediaContraints(shouldRequestAudio, shouldRequestVideo);
+            logger.log("Getting user media with constraints", constraints);
+            stream = await navigator.mediaDevices.getUserMedia(constraints);
+        }
+
+        this.userMediaStreams.push(stream);
+
+        return stream;
+    }
+
+    /**
+     * Stops all tracks on the provided usermedia stream
+     */
+    public stopUserMediaStream(mediaStream: MediaStream) {
+        logger.debug("Stopping usermedia stream", mediaStream.id);
+        for (const track of mediaStream.getTracks()) {
+            track.stop();
+        }
+
+        const index = this.userMediaStreams.indexOf(mediaStream);
+
+        if (index !== -1) {
+            logger.debug("Splicing usermedia stream out stream array", mediaStream.id);
+            this.userMediaStreams.splice(index, 1);
+        }
+    }
+
+    /**
+     * @returns {MediaStream} based on passed parameters
+     */
+    public async getScreensharingStream(desktopCapturerSourceId: string): Promise<MediaStream | null> {
+        let stream: MediaStream;
+
+        if (this.screensharingStreams.length === 0) {
+            const screenshareConstraints = this.getScreenshareContraints(desktopCapturerSourceId);
+            if (!screenshareConstraints) return null;
+
+            if (desktopCapturerSourceId) {
+                // We are using Electron
+                logger.debug("Getting screensharing stream using getUserMedia()", desktopCapturerSourceId);
+                stream = await navigator.mediaDevices.getUserMedia(screenshareConstraints);
+            } else {
+                // We are not using Electron
+                logger.debug("Getting screensharing stream using getDisplayMedia()");
+                stream = await navigator.mediaDevices.getDisplayMedia(screenshareConstraints);
+            }
+        } else {
+            const matchingStream = this.screensharingStreams[this.screensharingStreams.length - 1];
+            logger.log("Cloning screensharing stream", matchingStream.id);
+            stream = matchingStream.clone();
+        }
+
+        this.screensharingStreams.push(stream);
+
+        return stream;
+    }
+
+    /**
+     * Stops all tracks on the provided screensharing stream
+     */
+    public stopScreensharingStream(mediaStream: MediaStream) {
+        logger.debug("Stopping screensharing stream", mediaStream.id);
+        for (const track of mediaStream.getTracks()) {
+            track.stop();
+        }
+
+        const index = this.screensharingStreams.indexOf(mediaStream);
+
+        if (index !== -1) {
+            logger.debug("Splicing screensharing stream out stream array", mediaStream.id);
+            this.screensharingStreams.splice(index, 1);
+        }
+    }
+
+    /**
+     * Stops all local media tracks
+     */
+    public stopAllStreams() {
+        for (const stream of this.userMediaStreams) {
+            for (const track of stream.getTracks()) {
+                track.stop();
+            }
+        }
+
+        for (const stream of this.screensharingStreams) {
+            for (const track of stream.getTracks()) {
+                track.stop();
+            }
+        }
+
+        this.userMediaStreams = [];
+        this.screensharingStreams = [];
+    }
+
+    private getUserMediaContraints(audio: boolean, video: boolean): MediaStreamConstraints {
+        const isWebkit = !!navigator.webkitGetUserMedia;
+
+        return {
+            audio: audio
+                ? {
+                    deviceId: this.audioInput ? { ideal: this.audioInput } : undefined,
+                }
+                : false,
+            video: video
+                ? {
+                    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 },
+                }
+                : false,
+        };
+    }
+
+    private getScreenshareContraints(desktopCapturerSourceId?: string): DesktopCapturerConstraints {
+        if (desktopCapturerSourceId) {
+            logger.debug("Using desktop capturer source", desktopCapturerSourceId);
+            return {
+                audio: false,
+                video: {
+                    mandatory: {
+                        chromeMediaSource: "desktop",
+                        chromeMediaSourceId: desktopCapturerSourceId,
+                    },
+                },
+            };
+        } else {
+            logger.debug("Not using desktop capturer source");
+            return {
+                audio: false,
+                video: true,
+            };
+        }
+    }
+}
@@ -1,6 +1,7 @@
 {
  "extends": "./tsconfig.json",
  "compilerOptions": {
+    "declarationMap": true,
    "sourceMap": true,
    "noEmit": false,
    "emitDecoratorMetadata": true,