v14.0.0-rc.2

Prepare changelog for v14.0.0-rc.2
Merge pull request #1969 from matrix-org/t3chguy/cp/space-hierarchy
2021-10-07 17:42:40 +01:00 · 2021-10-07 17:42:40 +01:00 · 2021-10-06 16:51:32 +01:00 · 2021-10-06 13:29:13 +01:00 · 2021-10-04 11:55:19 +01:00 · 2021-10-04 11:55:19 +01:00
117 changed files with 11786 additions and 6839 deletions
@@ -0,0 +1 @@
+* @matrix-org/element-web
@@ -1,3 +1,7 @@
-<!-- Please read https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.rst before submitting your pull request -->
+<!-- Please read https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md before submitting your pull request -->

-<!-- Include a Sign-Off as described in https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.rst#sign-off -->
+<!-- Include a Sign-Off as described in https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md#sign-off -->
+
+<!-- To specify text for the changelog entry (otherwise the PR title will be used):
+Notes:
+-->
@@ -0,0 +1,12 @@
+name: Preview Changelog
+on:
+  pull_request_target:
+    types: [ opened, edited, labeled ]
+jobs:
+    changelog:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Preview Changelog
+              uses: matrix-org/allchange@main
+              with:
+                  ghToken: ${{ secrets.GITHUB_TOKEN }}
@@ -1,3 +1,132 @@
+Changes in [14.0.0-rc.2](https://github.com/vector-im/element-desktop/releases/tag/v14.0.0-rc.2) (2021-10-07)
+=============================================================================================================
+
+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)
+===================================================================================================
+
+## ✨ Features
+ * [Release] Exclude opt-in Element performance metrics from encryption ([\#1901](https://github.com/matrix-org/matrix-js-sdk/pull/1901)).
+ * Give `MatrixCall` the capability to emit `LengthChanged` events ([\#1873](https://github.com/matrix-org/matrix-js-sdk/pull/1873)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Improve browser example ([\#1875](https://github.com/matrix-org/matrix-js-sdk/pull/1875)). Contributed by [psrpinto](https://github.com/psrpinto).
+ * Give `CallFeed` the capability to emit on volume changes ([\#1865](https://github.com/matrix-org/matrix-js-sdk/pull/1865)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+## 🐛 Bug Fixes
+ * Fix verification request cancellation ([\#1871](https://github.com/matrix-org/matrix-js-sdk/pull/1871)).
+
+Changes in [12.4.1](https://github.com/vector-im/element-desktop/releases/tag/v12.4.1) (2021-09-13)
+===================================================================================================
+
+## 🔒 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)
+===================================================================================================
+
+## 🦖 Deprecations
+ * Deprecate groups APIs. Groups are no longer supported, only Synapse has support. They are being replaced by Spaces which build off of Rooms and are far more flexible. ([\#1792](https://github.com/matrix-org/matrix-js-sdk/pull/1792)).
+
+## ✨ Features
+ * Add method for including extra fields when uploading to a tree space ([\#1850](https://github.com/matrix-org/matrix-js-sdk/pull/1850)).
+
+## 🐛 Bug Fixes
+ * Fix broken voice calls, no ringing and broken call notifications ([\#1858](https://github.com/matrix-org/matrix-js-sdk/pull/1858)). Fixes vector-im/element-web#18578 vector-im/element-web#18538 and vector-im/element-web#18578. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Revert "Fix glare related regressions" ([\#1857](https://github.com/matrix-org/matrix-js-sdk/pull/1857)).
+ * Fix glare related regressions ([\#1851](https://github.com/matrix-org/matrix-js-sdk/pull/1851)). Fixes vector-im/element-web#18538 and vector-im/element-web#18538. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix temporary call messages being handled without call  ([\#1834](https://github.com/matrix-org/matrix-js-sdk/pull/1834)). Contributed by [Palid](https://github.com/Palid).
+ * Fix conditional on returning file tree spaces ([\#1841](https://github.com/matrix-org/matrix-js-sdk/pull/1841)).
+
+Changes in [12.3.1](https://github.com/vector-im/element-desktop/releases/tag/v12.3.1) (2021-08-17)
+===================================================================================================
+
+## 🐛 Bug Fixes
+ * Fix multiple VoIP regressions ([\#1860](https://github.com/matrix-org/matrix-js-sdk/pull/1860)).
+
+Changes in [12.3.0](https://github.com/vector-im/element-desktop/releases/tag/v12.3.0) (2021-08-16)
+===================================================================================================
+
+## ✨ Features
+ * Support for MSC3291: Muting in VoIP calls ([\#1812](https://github.com/matrix-org/matrix-js-sdk/pull/1812)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Support for screen-sharing using multi-stream VoIP (MSC3077) ([\#1685](https://github.com/matrix-org/matrix-js-sdk/pull/1685)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Handle DTMF support ([\#1813](https://github.com/matrix-org/matrix-js-sdk/pull/1813)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+## 🐛 Bug Fixes
+ * [Release] Fix glare related regressions ([\#1854](https://github.com/matrix-org/matrix-js-sdk/pull/1854)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix the types in shipped package ([\#1842](https://github.com/matrix-org/matrix-js-sdk/pull/1842)). Fixes vector-im/element-web#18503 and vector-im/element-web#18503.
+ * Fix error on turning off screensharing ([\#1833](https://github.com/matrix-org/matrix-js-sdk/pull/1833)). Fixes vector-im/element-web#18449. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix blank profile in join events ([\#1837](https://github.com/matrix-org/matrix-js-sdk/pull/1837)). Fixes vector-im/element-web#18321.
+ * fix TURN by fixing regression preventing multiple ICE candidates from sending. ([\#1838](https://github.com/matrix-org/matrix-js-sdk/pull/1838)).
+ * Send `user_hangup` reason if the opponent supports it ([\#1820](https://github.com/matrix-org/matrix-js-sdk/pull/1820)). Fixes vector-im/element-web#18219. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Apply hidden char check to rawDisplayName too ([\#1816](https://github.com/matrix-org/matrix-js-sdk/pull/1816)).
+ * Only clear bit 63 when we create the IV ([\#1819](https://github.com/matrix-org/matrix-js-sdk/pull/1819)).
+
+Changes in [12.2.0](https://github.com/vector-im/element-desktop/releases/tag/v12.2.0) (2021-08-02)
+===================================================================================================
+
+## ✨ Features
+ * Improve calculateRoomName performances by using Intl.Collator
+   [\#1801](https://github.com/matrix-org/matrix-js-sdk/pull/1801)
+ * Switch callEventHandler from listening on `event` to `Room.timeline`
+   [\#1789](https://github.com/matrix-org/matrix-js-sdk/pull/1789)
+ * Expose MatrixEvent's internal clearEvent as a function
+   [\#1784](https://github.com/matrix-org/matrix-js-sdk/pull/1784)
+
+## 🐛 Bug Fixes
+ * Clean up Event.clearEvent handling to fix a bug where malformed events with falsey content wouldn't be considered decrypted
+   [\#1807](https://github.com/matrix-org/matrix-js-sdk/pull/1807)
+ * Standardise spelling and casing of homeserver, identity server, and integration manager
+   [\#1782](https://github.com/matrix-org/matrix-js-sdk/pull/1782)
+
 Changes in [12.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.1.0) (2021-07-19)
 ==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.1.0-rc.1...v12.1.0)
@@ -0,0 +1,215 @@
+Contributing code to matrix-js-sdk
+==================================
+
+Everyone is welcome to contribute code to matrix-js-sdk, provided that they are
+willing to license their contributions under the same license as the project
+itself. We follow a simple 'inbound=outbound' model for contributions: the act
+of submitting an 'inbound' contribution means that the contributor agrees to
+license the code under the same terms as the project's overall 'outbound'
+license - in this case, Apache Software License v2 (see
+[LICENSE](LICENSE)).
+
+How to contribute
+-----------------
+
+The preferred and easiest way to contribute changes to the project is to fork
+it on github, and then create a pull request to ask us to pull your changes
+into our repo (https://help.github.com/articles/using-pull-requests/)
+
+We use GitHub's pull request workflow to review the contribution, and either
+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)
+ * 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
+   you did. If this isn't obvious from your code, you haven't written enough
+   comments.
+
+We rely on information in pull request to populate the information that goes
+into the changelogs our users see, both for the JS SDK itself and also for some
+projects based on it. This is picked up from both labels on the pull request and
+the `Notes:` annotation in the description. By default, the PR title will be
+used for the changelog entry, but you can specify more options, as follows.
+
+To add a longer, more detailed description of the change for the changelog:
+
+
+*Fix llama herding bug*
+
+```
+Notes: Fix a bug (https://github.com/matrix-org/notaproject/issues/123) where the 'Herd' button would not herd more than 8 Llamas if the moon was in the waxing gibbous phase
+```
+
+For some PRs, it's not useful to have an entry in the user-facing changelog (this is
+the default for PRs labelled with `T-Task`):
+
+*Remove outdated comment from `Ungulates.ts`*
+```
+Notes: none
+```
+
+Sometimes, you're fixing a bug in a downstream project, in which case you want
+an entry in that project's changelog. You can do that too:
+
+*Fix another herding bug*
+```
+Notes: Fix a bug where the `herd()` function would only work on Tuesdays
+element-web notes: Fix a bug where the 'Herd' button only worked on Tuesdays
+```
+
+This example is for Element Web. You can specify:
+ * matrix-react-sdk
+ * element-web
+ * element-desktop
+
+If your PR introduces a breaking change, use the `Notes` section in the same
+way, additionally adding the `X-Breaking-Change` label (see below). There's no need
+to specify in the notes that it's a breaking change - this will be added
+automatically based on the label - but remember to tell the developer how to
+migrate:
+
+*Remove legacy class*
+
+```
+Notes: Remove legacy `Camelopard` class. `Giraffe` should be used instead.
+```
+
+Other metadata can be added using labels.
+ * `X-Breaking-Change`: A breaking change - adding this label will mean the change causes a *major* version bump.
+ * `T-Enhancement`: A new feature - adding this label will mean the change causes a *minor* version bump.
+ * `T-Defect`: A bug fix (in either code or docs).
+ * `T-Task`: No user-facing changes, eg. code comments, CI fixes, refactors or tests. Won't have a changelog entry unless you specify one.
+
+If you don't have permission to add labels, your PR reviewer(s) can work with you
+to add them: ask in the PR description or comments.
+
+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
+TypeScript and existing files should use ES6 principles where possible.
+
+Members should not be exported as a default export in general - it causes problems
+with the architecture of the SDK (index file becomes less clear) and could
+introduce naming problems (as default exports get aliased upon import). In
+general, avoid using `export default`.
+
+The remaining code-style for matrix-js-sdk is not formally documented, but
+contributors are encouraged to read the
+[code style document for matrix-react-sdk](https://github.com/matrix-org/matrix-react-sdk/blob/master/code_style.md)
+and follow the principles set out there.
+
+Please ensure your changes match the cosmetic style of the existing project,
+and ***never*** mix cosmetic and functional changes in the same commit, as it
+makes it horribly hard to review otherwise.
+
+Attribution
+-----------
+Everyone who contributes anything to Matrix is welcome to be listed in the
+AUTHORS.rst file for the project in question. Please feel free to include a
+change to AUTHORS.rst in your pull request to list yourself and a short
+description of the area(s) you've worked on. Also, we sometimes have swag to
+give away to contributors - if you feel that Matrix-branded apparel is missing
+from your life, please mail us your shipping address to matrix at matrix.org
+and we'll try to fix it :)
+
+Sign off
+--------
+In order to have a concrete record that your contribution is intentional
+and you agree to license it under the same terms as the project's license, we've
+adopted the same lightweight approach that the Linux Kernel
+(https://www.kernel.org/doc/Documentation/SubmittingPatches), Docker
+(https://github.com/docker/docker/blob/master/CONTRIBUTING.md), and many other
+projects use: the DCO (Developer Certificate of Origin:
+http://developercertificate.org/). This is a simple declaration that you wrote
+the contribution or otherwise have the right to contribute it to Matrix:
+
+```
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+660 York Street, Suite 102,
+San Francisco, CA 94110 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+```
+
+If you agree to this for your contribution, then all that's needed is to
+include the line in your commit or pull request comment:
+
+```
+Signed-off-by: Your Name <your@email.example.org>
+```
+
+We accept contributions under a legally identifiable name, such as your name on
+government documentation or common-law names (names claimed by legitimate usage
+or repute). Unfortunately, we cannot accept anonymous contributions at this
+time.
+
+Git allows you to add this signoff automatically when using the `-s` flag to
+`git commit`, which uses the name and email set in your `user.name` and
+`user.email` git configs.
+
+If you forgot to sign off your commits before making your pull request and are
+on Git 2.17+ you can mass signoff using rebase:
+
+```
+git rebase --signoff origin/develop
+```
@@ -1,131 +0,0 @@
-Contributing code to matrix-js-sdk
-==================================
-
-Everyone is welcome to contribute code to matrix-js-sdk, provided that they are
-willing to license their contributions under the same license as the project
-itself. We follow a simple 'inbound=outbound' model for contributions: the act
-of submitting an 'inbound' contribution means that the contributor agrees to
-license the code under the same terms as the project's overall 'outbound'
-license - in this case, Apache Software License v2 (see `<LICENSE>`_).
-
-How to contribute
-~~~~~~~~~~~~~~~~~
-
-The preferred and easiest way to contribute changes to the project is to fork
-it on github, and then create a pull request to ask us to pull your changes
-into our repo (https://help.github.com/articles/using-pull-requests/)
-
-**The single biggest thing you need to know is: please base your changes on
-the develop branch - /not/ master.**
-
-We use the master branch to track the most recent release, so that folks who
-blindly clone the repo and automatically check out master get something that
-works. Develop is the unstable branch where all the development actually
-happens: the workflow is that contributors should fork the develop branch to
-make a 'feature' branch for a particular contribution, and then make a pull
-request to merge this back into the matrix.org 'official' develop branch. We
-use GitHub's pull request workflow to review the contribution, and either ask
-you to make any refinements needed or merge it and make them ourselves. The
-changes will then land on master when we next do a release.
-
-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.
-
-Code style
-~~~~~~~~~~
-
-The js-sdk aims to target TypeScript/ES6. All new files should be written in
-TypeScript and existing files should use ES6 principles where possible.
-
-Members should not be exported as a default export in general - it causes problems
-with the architecture of the SDK (index file becomes less clear) and could
-introduce naming problems (as default exports get aliased upon import). In
-general, avoid using `export default`.
-
-The remaining code-style for matrix-js-sdk is not formally documented, but
-contributors are encouraged to read the code style document for matrix-react-sdk
-(`<https://github.com/matrix-org/matrix-react-sdk/blob/master/code_style.md>`_)
-and follow the principles set out there.
-
-Please ensure your changes match the cosmetic style of the existing project,
-and **never** mix cosmetic and functional changes in the same commit, as it
-makes it horribly hard to review otherwise.
-
-Attribution
-~~~~~~~~~~~
-
-Everyone who contributes anything to Matrix is welcome to be listed in the
-AUTHORS.rst file for the project in question. Please feel free to include a
-change to AUTHORS.rst in your pull request to list yourself and a short
-description of the area(s) you've worked on. Also, we sometimes have swag to
-give away to contributors - if you feel that Matrix-branded apparel is missing
-from your life, please mail us your shipping address to matrix at matrix.org
-and we'll try to fix it :)
-
-Sign off
-~~~~~~~~
-
-In order to have a concrete record that your contribution is intentional
-and you agree to license it under the same terms as the project's license, we've
-adopted the same lightweight approach that the Linux Kernel
-(https://www.kernel.org/doc/Documentation/SubmittingPatches), Docker
-(https://github.com/docker/docker/blob/master/CONTRIBUTING.md), and many other
-projects use: the DCO (Developer Certificate of Origin:
-http://developercertificate.org/). This is a simple declaration that you wrote
-the contribution or otherwise have the right to contribute it to Matrix::
-
-    Developer Certificate of Origin
-    Version 1.1
-
-    Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
-    660 York Street, Suite 102,
-    San Francisco, CA 94110 USA
-
-    Everyone is permitted to copy and distribute verbatim copies of this
-    license document, but changing it is not allowed.
-
-    Developer's Certificate of Origin 1.1
-
-    By making a contribution to this project, I certify that:
-
-    (a) The contribution was created in whole or in part by me and I
-        have the right to submit it under the open source license
-        indicated in the file; or
-
-    (b) The contribution is based upon previous work that, to the best
-        of my knowledge, is covered under an appropriate open source
-        license and I have the right under that license to submit that
-        work with modifications, whether created in whole or in part
-        by me, under the same open source license (unless I am
-        permitted to submit under a different license), as indicated
-        in the file; or
-
-    (c) The contribution was provided directly to me by some other
-        person who certified (a), (b) or (c) and I have not modified
-        it.
-
-    (d) I understand and agree that this project and the contribution
-        are public and that a record of the contribution (including all
-        personal information I submit with it, including my sign-off) is
-        maintained indefinitely and may be redistributed consistent with
-        this project or the open source license(s) involved.
-
-If you agree to this for your contribution, then all that's needed is to
-include the line in your commit or pull request comment::
-
-    Signed-off-by: Your Name <your@email.example.org>
-
-We accept contributions under a legally identifiable name, such as your name on
-government documentation or common-law names (names claimed by legitimate usage
-or repute). Unfortunately, we cannot accept anonymous contributions at this
-time.
-
-Git allows you to add this signoff automatically when using the ``-s`` flag to
-``git commit``, which uses the name and email set in your ``user.name`` and
-``user.email`` git configs.
-
-If you forgot to sign off your commits before making your pull request and are
-on Git 2.17+ you can mass signoff using rebase::
-
-    git rebase --signoff origin/develop
@@ -1,6 +1,6 @@
 console.log("Loading browser sdk");

-var client = matrixcs.createClient("http://matrix.org");
+var client = matrixcs.createClient("https://matrix.org");
 client.publicRooms(function (err, data) {
    if (err) {
 	   console.error("err %s", JSON.stringify(err));
@@ -1,6 +1,8 @@
-<html>
+<html lang="en">
 <head>
 <title>Test</title>
+<meta charset="utf-8"/>
+<link rel="icon" href="data:,">
 <script src="lib/matrix.js"></script>
 <script src="browserTest.js"></script>
 </head>
@@ -1,6 +1,6 @@
 {
  "name": "matrix-js-sdk",
-  "version": "12.1.0",
+  "version": "14.0.0-rc.2",
  "description": "Matrix Client-Server SDK for Javascript",
  "scripts": {
    "prepublishOnly": "yarn build",
@@ -9,13 +9,14 @@
    "clean": "rimraf lib dist",
    "build": "yarn build:dev && yarn build:compile-browser && yarn build:minify-browser",
    "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
-    "build:types": "tsc --emitDeclarationOnly",
+    "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
    "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
-    "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.js -p [ tsify -p ./tsconfig.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
+    "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.js -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
    "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
    "gendoc": "jsdoc -c jsdoc.json -P package.json",
    "lint": "yarn lint:types && yarn lint:js",
-    "lint:js": "eslint --max-warnings 57 src spec",
+    "lint:js": "eslint --max-warnings 7 src spec",
+    "lint:js-fix": "eslint --fix src spec",
    "lint:types": "tsc --noEmit",
    "test": "jest",
    "test:watch": "jest --watch",
@@ -80,14 +81,15 @@
    "@types/request": "^2.48.5",
    "@typescript-eslint/eslint-plugin": "^4.17.0",
    "@typescript-eslint/parser": "^4.17.0",
+    "allchange": "^1.0.2",
    "babel-jest": "^26.6.3",
    "babelify": "^10.0.0",
-    "better-docs": "^2.3.2",
+    "better-docs": "^2.4.0-beta.9",
    "browserify": "^17.0.0",
    "docdash": "^1.2.0",
    "eslint": "7.18.0",
    "eslint-config-google": "^0.14.0",
-    "eslint-plugin-matrix-org": "github:matrix-org/eslint-plugin-matrix-org#main",
+    "eslint-plugin-matrix-org": "github:matrix-org/eslint-plugin-matrix-org#2306b3d4da4eba908b256014b979f1d3d43d2945",
    "exorcist": "^1.0.1",
    "fake-indexeddb": "^3.1.2",
    "jest": "^26.6.3",
@@ -102,11 +102,6 @@ yarn cache clean
 # Ensure all dependencies are updated
 yarn install --ignore-scripts --pure-lockfile

-if [ -z "$skip_changelog" ]; then
-    # update_changelog doesn't have a --version flag
-    update_changelog -h > /dev/null || (echo "github-changelog-generator is required: please install it"; exit)
-fi
-
 # Login and publish continues to use `npm`, as it seems to have more clearly
 # defined options and semantics than `yarn` for writing to the registry.
 if [ -z "$skip_npm" ]; then
@@ -133,14 +128,6 @@ if [ $prerelease -eq 1 ]; then
    echo Making a PRE-RELEASE
 fi

-if [ -z "$skip_changelog" ]; then
-    if ! command -v update_changelog >/dev/null 2>&1; then
-        echo "release.sh requires github-changelog-generator. Try:" >&2
-        echo "    pip install git+https://github.com/matrix-org/github-changelog-generator.git" >&2
-        exit 1
-    fi
-fi
-
 # we might already be on the release branch, in which case, yay
 # If we're on any branch starting with 'release', we don't create
 # a separate release branch (this allows us to use the same
@@ -156,7 +143,7 @@ fi

 if [ -z "$skip_changelog" ]; then
    echo "Generating changelog"
-    update_changelog -f "$changelog_file" "$release"
+    yarn run allchange "$release"
    read -p "Edit $changelog_file manually, or press enter to continue " REPLY

    if [ -n "$(git ls-files --modified $changelog_file)" ]; then
@@ -204,7 +191,10 @@ git commit package.json $pkglock -m "$tag"
 # figure out if we should be signing this release
 signing_id=
 if [ -f release_config.yaml ]; then
-    signing_id=`cat release_config.yaml | python -c "import yaml; import sys; print yaml.load(sys.stdin)['signing_id']"`
+    result=`cat release_config.yaml | python -c "import yaml; import sys; print yaml.load(sys.stdin)['signing_id']" 2> /dev/null || true`
+    if [ "$?" -eq 0 ]; then
+        signing_id=$result
+    fi
 fi


@@ -1025,4 +1025,68 @@ describe("megolm", function() {
            });
        });
    });
+
+    it("Alice can decrypt a message with falsey content", function() {
+        return aliceTestClient.start().then(() => {
+            return createOlmSession(testOlmAccount, aliceTestClient);
+        }).then((p2pSession) => {
+            const groupSession = new Olm.OutboundGroupSession();
+            groupSession.create();
+
+            // make the room_key event
+            const roomKeyEncrypted = encryptGroupSessionKey({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            const plaintext = {
+                type: "m.room.message",
+                content: undefined,
+                room_id: ROOM_ID,
+            };
+
+            const messageEncrypted = {
+                event_id: 'test_megolm_event',
+                content: {
+                    algorithm: "m.megolm.v1.aes-sha2",
+                    ciphertext: groupSession.encrypt(JSON.stringify(plaintext)),
+                    device_id: "testDevice",
+                    sender_key: testSenderKey,
+                    session_id: groupSession.session_id(),
+                },
+                type: "m.room.encrypted",
+            };
+
+            // Alice gets both the events in a single sync
+            const syncResponse = {
+                next_batch: 1,
+                to_device: {
+                    events: [roomKeyEncrypted],
+                },
+                rooms: {
+                    join: {},
+                },
+            };
+            syncResponse.rooms.join[ROOM_ID] = {
+                timeline: {
+                    events: [messageEncrypted],
+                },
+            };
+
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            const room = aliceTestClient.client.getRoom(ROOM_ID);
+            const event = room.getLiveTimeline().getEvents()[0];
+            expect(event.isEncrypted()).toBe(true);
+            return testUtils.awaitDecryption(event);
+        }).then((event) => {
+            expect(event.getRoomId()).toEqual(ROOM_ID);
+            expect(event.getContent()).toEqual({});
+            expect(event.getClearContent()).toBeUndefined();
+        });
+    });
 });
@@ -91,7 +91,7 @@ export function mkEvent(opts) {
        event.state_key = opts.skey;
    } else if (["m.room.name", "m.room.topic", "m.room.create", "m.room.join_rules",
         "m.room.power_levels", "m.room.topic",
-         "com.example.state"].indexOf(opts.type) !== -1) {
+         "com.example.state"].includes(opts.type)) {
        event.state_key = "";
    }
    return opts.event ? new MatrixEvent(event) : event;
@@ -274,7 +274,7 @@ describe("Crypto", function() {
                    // alice encrypts each event, and then bob tries to decrypt
                    // them without any keys, so that they'll be in pending
                    await aliceClient.crypto.encryptEvent(event, aliceRoom);
-                    event.clearEvent = {};
+                    event.clearEvent = undefined;
                    event.senderCurve25519Key = null;
                    event.claimedEd25519Key = null;
                    try {
@@ -256,97 +256,145 @@ describe("MegolmDecryption", function() {
            });
        });

-        it("re-uses sessions for sequential messages", async function() {
-            mockCrypto.backupManager = {
-                backupGroupSession: () => {},
-            };
-            const mockStorage = new MockStorageApi();
-            const cryptoStore = new MemoryCryptoStore(mockStorage);
+        describe("session reuse and key reshares", () => {
+            let megolmEncryption;
+            let aliceDeviceInfo;
+            let mockRoom;
+            let olmDevice;

-            const olmDevice = new OlmDevice(cryptoStore);
-            olmDevice.verifySignature = jest.fn();
-            await olmDevice.init();
+            beforeEach(async () => {
+                mockCrypto.backupManager = {
+                    backupGroupSession: () => {},
+                };
+                const mockStorage = new MockStorageApi();
+                const cryptoStore = new MemoryCryptoStore(mockStorage);

-            mockBaseApis.claimOneTimeKeys = jest.fn().mockReturnValue(Promise.resolve({
-                one_time_keys: {
-                    '@alice:home.server': {
-                        aliceDevice: {
-                            'signed_curve25519:flooble': {
-                                key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
-                                signatures: {
-                                    '@alice:home.server': {
-                                        'ed25519:aliceDevice': 'totally valid',
+                olmDevice = new OlmDevice(cryptoStore);
+                olmDevice.verifySignature = jest.fn();
+                await olmDevice.init();
+
+                mockBaseApis.claimOneTimeKeys = jest.fn().mockReturnValue(Promise.resolve({
+                    one_time_keys: {
+                        '@alice:home.server': {
+                            aliceDevice: {
+                                'signed_curve25519:flooble': {
+                                    key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
+                                    signatures: {
+                                        '@alice:home.server': {
+                                            'ed25519:aliceDevice': 'totally valid',
+                                        },
                                    },
                                },
                            },
                        },
                    },
-                },
-            }));
-            mockBaseApis.sendToDevice = jest.fn().mockResolvedValue(undefined);
+                }));
+                mockBaseApis.sendToDevice = jest.fn().mockResolvedValue(undefined);

-            mockCrypto.downloadKeys.mockReturnValue(Promise.resolve({
-                '@alice:home.server': {
-                    aliceDevice: {
-                        deviceId: 'aliceDevice',
-                        isBlocked: jest.fn().mockReturnValue(false),
-                        isUnverified: jest.fn().mockReturnValue(false),
-                        getIdentityKey: jest.fn().mockReturnValue(
-                            'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
-                        ),
-                        getFingerprint: jest.fn().mockReturnValue(''),
+                aliceDeviceInfo = {
+                    deviceId: 'aliceDevice',
+                    isBlocked: jest.fn().mockReturnValue(false),
+                    isUnverified: jest.fn().mockReturnValue(false),
+                    getIdentityKey: jest.fn().mockReturnValue(
+                        'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
+                    ),
+                    getFingerprint: jest.fn().mockReturnValue(''),
+                };
+
+                mockCrypto.downloadKeys.mockReturnValue(Promise.resolve({
+                    '@alice:home.server': {
+                        aliceDevice: aliceDeviceInfo,
                    },
-                },
-            }));
+                }));

-            mockCrypto.checkDeviceTrust.mockReturnValue({
-                isVerified: () => false,
+                mockCrypto.checkDeviceTrust.mockReturnValue({
+                    isVerified: () => false,
+                });
+
+                megolmEncryption = new MegolmEncryption({
+                    userId: '@user:id',
+                    crypto: mockCrypto,
+                    olmDevice: olmDevice,
+                    baseApis: mockBaseApis,
+                    roomId: ROOM_ID,
+                    config: {
+                        rotation_period_ms: 9999999999999,
+                    },
+                });
+                mockRoom = {
+                    getEncryptionTargetMembers: jest.fn().mockReturnValue(
+                        [{ userId: "@alice:home.server" }],
+                    ),
+                    getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
+                };
            });

-            const megolmEncryption = new MegolmEncryption({
-                userId: '@user:id',
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: mockBaseApis,
-                roomId: ROOM_ID,
-                config: {
-                    rotation_period_ms: 9999999999999,
-                },
-            });
-            const mockRoom = {
-                getEncryptionTargetMembers: jest.fn().mockReturnValue(
-                    [{ userId: "@alice:home.server" }],
-                ),
-                getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
-            };
-            const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                body: "Some text",
-            });
-            expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
+            it("re-uses sessions for sequential messages", async function() {
+                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some text",
+                });
+                expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();

-            // this should have claimed a key for alice as it's starting a new session
-            expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-            );
-            expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
-                ['@alice:home.server'], false,
-            );
-            expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
-            expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-            );
+                // this should have claimed a key for alice as it's starting a new session
+                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
+                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
+                );
+                expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
+                    ['@alice:home.server'], false,
+                );
+                expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
+                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
+                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
+                );

-            mockBaseApis.claimOneTimeKeys.mockReset();
+                mockBaseApis.claimOneTimeKeys.mockReset();

-            const ct2 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                body: "Some more text",
+                const ct2 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some more text",
+                });
+
+                // this should *not* have claimed a key as it should be using the same session
+                expect(mockBaseApis.claimOneTimeKeys).not.toHaveBeenCalled();
+
+                // likewise they should show the same session ID
+                expect(ct2.session_id).toEqual(ct1.session_id);
            });

-            // this should *not* have claimed a key as it should be using the same session
-            expect(mockBaseApis.claimOneTimeKeys).not.toHaveBeenCalled();
+            it("re-shares keys to devices it's already sent to", async function() {
+                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some text",
+                });

-            // likewise they should show the same session ID
-            expect(ct2.session_id).toEqual(ct1.session_id);
+                mockBaseApis.sendToDevice.mockClear();
+                await megolmEncryption.reshareKeyWithDevice(
+                    olmDevice.deviceCurve25519Key,
+                    ct1.session_id,
+                    '@alice:home.server',
+                    aliceDeviceInfo,
+                );
+
+                expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
+            });
+
+            it("does not re-share keys to devices whose keys have changed", async function() {
+                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some text",
+                });
+
+                aliceDeviceInfo.getIdentityKey = jest.fn().mockReturnValue(
+                    'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWI',
+                );
+
+                mockBaseApis.sendToDevice.mockClear();
+                await megolmEncryption.reshareKeyWithDevice(
+                    olmDevice.deviceCurve25519Key,
+                    ct1.session_id,
+                    '@alice:home.server',
+                    aliceDeviceInfo,
+                );
+
+                expect(mockBaseApis.sendToDevice).not.toHaveBeenCalled();
+            });
        });
    });

@@ -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();

@@ -237,6 +237,7 @@ describe("MatrixClient", function() {
    it("should get (unstable) file trees with valid state", async () => {
        const roomId = "!room:example.org";
        const mockRoom = {
+            getMyMembership: () => "join",
            currentState: {
                getStateEvents: (eventType, stateKey) => {
                    if (eventType === EventType.RoomCreate) {
@@ -270,9 +271,33 @@ describe("MatrixClient", function() {
        expect(tree.room).toBe(mockRoom);
    });

+    it("should not get (unstable) file trees if not joined", async () => {
+        const roomId = "!room:example.org";
+        const mockRoom = {
+            getMyMembership: () => "leave", // "not join"
+        };
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return mockRoom;
+        };
+        const tree = client.unstableGetFileTreeSpace(roomId);
+        expect(tree).toBeFalsy();
+    });
+
+    it("should not get (unstable) file trees for unknown rooms", async () => {
+        const roomId = "!room:example.org";
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return null; // imply unknown
+        };
+        const tree = client.unstableGetFileTreeSpace(roomId);
+        expect(tree).toBeFalsy();
+    });
+
    it("should not get (unstable) file trees with invalid create contents", async () => {
        const roomId = "!room:example.org";
        const mockRoom = {
+            getMyMembership: () => "join",
            currentState: {
                getStateEvents: (eventType, stateKey) => {
                    if (eventType === EventType.RoomCreate) {
@@ -307,6 +332,7 @@ describe("MatrixClient", function() {
    it("should not get (unstable) file trees with invalid purpose/subtype contents", async () => {
        const roomId = "!room:example.org";
        const mockRoom = {
+            getMyMembership: () => "join",
            currentState: {
                getStateEvents: (eventType, stateKey) => {
                    if (eventType === EventType.RoomCreate) {
@@ -14,22 +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 { MatrixEvent } from "../../../src/models/event";
-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: MatrixEvent;
+    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 = {
@@ -47,11 +50,16 @@ describe("MSC3089Branch", () => {
                }
            },
        };
-        indexEvent = {
+        indexEvent = ({
            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', () => {
@@ -70,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
            });
@@ -84,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 () => {
@@ -128,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}`;
@@ -152,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,
+        ]);
+    });
 });
@@ -29,7 +29,7 @@ import { MatrixError } from "../../../src/http-api";

 describe("MSC3089TreeSpace", () => {
    let client: MatrixClient;
-    let room: Room;
+    let room: any;
    let tree: MSC3089TreeSpace;
    const roomId = "!tree:localhost";
    const targetUser = "@target:example.org";
@@ -170,7 +170,7 @@ describe("MSC3089TreeSpace", () => {
            expect(userIds).toMatchObject([target]);
            return Promise.resolve();
        });
-        client.invite = () => Promise.resolve(); // we're not testing this here - see other tests
+        client.invite = () => Promise.resolve({}); // we're not testing this here - see other tests
        client.sendSharedHistoryKeys = sendKeysFn;

        // Mock the history check as best as possible
@@ -198,7 +198,7 @@ describe("MSC3089TreeSpace", () => {
            expect(userIds).toMatchObject([target]);
            return Promise.resolve();
        });
-        client.invite = () => Promise.resolve(); // we're not testing this here - see other tests
+        client.invite = () => Promise.resolve({}); // we're not testing this here - see other tests
        client.sendSharedHistoryKeys = sendKeysFn;

        const historyVis = "joined"; // NOTE: Changed.
@@ -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', () => {
@@ -446,9 +471,9 @@ describe("MSC3089TreeSpace", () => {
        // Danger: these are partial implementations for testing purposes only

        // @ts-ignore - "MatrixEvent is a value but used as a type", which is true but not important
-        let childState: { [roomId: string]: MatrixEvent[] } = {};
+        let childState: { [roomId: string]: any[] } = {};
        // @ts-ignore - "MatrixEvent is a value but used as a type", which is true but not important
-        let parentState: MatrixEvent[] = [];
+        let parentState: any[] = [];
        let parentRoom: Room;
        let childTrees: MSC3089TreeSpace[];
        let rooms: { [roomId: string]: Room };
@@ -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);
+    });
 });
@@ -16,11 +16,13 @@ limitations under the License.

 import { EventTimelineSet } from "../../src/models/event-timeline-set";
 import { MatrixEvent } from "../../src/models/event";
+import { Room } from "../../src/models/room";
 import { Relations } from "../../src/models/relations";

 describe("Relations", function() {
    it("should deduplicate annotations", function() {
-        const relations = new Relations("m.annotation", "m.reaction");
+        const room = new Room("room123", null, null);
+        const relations = new Relations("m.annotation", "m.reaction", room);

        // Create an instance of an annotation
        const eventData = {
@@ -95,10 +97,8 @@ describe("Relations", function() {
        });

        // Stub the room
-        const room = {
-            getPendingEvent() { return null; },
-            getUnfilteredTimelineSet() { return null; },
-        };
+
+        const room = new Room("room123", null, null);

        // Add the target event first, then the relation event
        {
@@ -1,8 +1,9 @@
 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";
+import { UNSTABLE_ELEMENT_FUNCTIONAL_USERS } from "../../src/@types/event";
 import { TestClient } from "../TestClient";

 describe("Room", function() {
@@ -112,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);
        });

@@ -1456,4 +1457,291 @@ describe("Room", function() {
            expect(room.maySendMessage()).toEqual(true);
        });
    });
+
+    describe("getDefaultRoomName", function() {
+        it("should return 'Empty room' if a user is the only member",
+        function() {
+            const room = new Room(roomId, null, userA);
+            expect(room.getDefaultRoomName(userA)).toEqual("Empty room");
+        });
+
+        it("should return a display name if one other member is in the room",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "join",
+                    room: roomId, event: true, name: "User B",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("User B");
+        });
+
+        it("should return a display name if one other member is banned",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "ban",
+                    room: roomId, event: true, name: "User B",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("Empty room (was User B)");
+        });
+
+        it("should return a display name if one other member is invited",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "invite",
+                    room: roomId, event: true, name: "User B",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("User B");
+        });
+
+        it("should return 'Empty room (was User B)' if User B left the room",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "leave",
+                    room: roomId, event: true, name: "User B",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("Empty room (was User B)");
+        });
+
+        it("should return 'User B and User C' if in a room with two other users",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "join",
+                    room: roomId, event: true, name: "User B",
+                }),
+                utils.mkMembership({
+                    user: userC, mship: "join",
+                    room: roomId, event: true, name: "User C",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("User B and User C");
+        });
+
+        it("should return 'User B and 2 others' if in a room with three other users",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "join",
+                    room: roomId, event: true, name: "User B",
+                }),
+                utils.mkMembership({
+                    user: userC, mship: "join",
+                    room: roomId, event: true, name: "User C",
+                }),
+                utils.mkMembership({
+                    user: userD, mship: "join",
+                    room: roomId, event: true, name: "User D",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("User B and 2 others");
+        });
+
+        describe("io.element.functional_users", function() {
+            it("should return a display name (default behaviour) if no one is marked as a functional member",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true,
+                        content: {
+                            service_members: [],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+
+            it("should return a display name (default behaviour) if service members is a number (invalid)",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true,
+                        content: {
+                            service_members: 1,
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+
+            it("should return a display name (default behaviour) if service members is a string (invalid)",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true,
+                        content: {
+                            service_members: userB,
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+
+            it("should return 'Empty room' if the only other member is a functional member",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true,
+                        content: {
+                            service_members: [userB],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("Empty room");
+            });
+
+            it("should return 'User B' if User B is the only other member who isn't a functional member",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkMembership({
+                        user: userC, mship: "join",
+                        room: roomId, event: true, name: "User C",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true, user: userA,
+                        content: {
+                            service_members: [userC],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+
+            it("should return 'Empty room' if all other members are functional members",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkMembership({
+                        user: userC, mship: "join",
+                        room: roomId, event: true, name: "User C",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true, user: userA,
+                        content: {
+                            service_members: [userB, userC],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("Empty room");
+            });
+
+            it("should not break if an unjoined user is marked as a service user",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true, user: userA,
+                        content: {
+                            service_members: [userC],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+        });
+    });
 });
@@ -493,4 +493,68 @@ describe("utils", function() {
            expect(deepSortedObjectEntries(input)).toMatchObject(output);
        });
    });
+
+    describe("recursivelyAssign", () => {
+        it("doesn't override with null/undefined", () => {
+            const result = utils.recursivelyAssign(
+                {
+                    string: "Hello world",
+                    object: {},
+                    float: 0.1,
+                }, {
+                    string: null,
+                    object: undefined,
+                },
+                true,
+            );
+
+            expect(result).toStrictEqual({
+                string: "Hello world",
+                object: {},
+                float: 0.1,
+            });
+        });
+
+        it("assigns recursively", () => {
+            const result = utils.recursivelyAssign(
+                {
+                    number: 42,
+                    object: {
+                        message: "Hello world",
+                        day: "Monday",
+                        langs: {
+                            compiled: ["c++"],
+                        },
+                    },
+                    thing: "string",
+                }, {
+                    number: 2,
+                    object: {
+                        message: "How are you",
+                        day: "Friday",
+                        langs: {
+                            compiled: ["c++", "c"],
+                        },
+                    },
+                    thing: {
+                        aSubThing: "something",
+                    },
+                },
+            );
+
+            expect(result).toStrictEqual({
+                number: 2,
+                object: {
+                    message: "How are you",
+                    day: "Friday",
+                    langs: {
+                        compiled: ["c++", "c"],
+                    },
+                },
+                thing: {
+                    aSubThing: "something",
+                },
+            });
+        });
+    });
 });
@@ -16,6 +16,7 @@ limitations under the License.

 import { TestClient } from '../../TestClient';
 import { MatrixCall, CallErrorCode, CallEvent } from '../../../src/webrtc/call';
+import { SDPStreamMetadataKey, SDPStreamMetadataPurpose } from '../../../src/webrtc/callEventTypes';

 const DUMMY_SDP = (
    "v=0\r\n" +
@@ -82,6 +83,17 @@ class MockRTCPeerConnection {
    getStats() { return []; }
 }

+class MockMediaStream {
+    constructor(
+        public id,
+    ) {}
+
+    getTracks() { return []; }
+    getAudioTracks() { return [{ enabled: true }]; }
+    getVideoTracks() { return [{ enabled: true }]; }
+    addEventListener() {}
+}
+
 describe('Call', function() {
    let client;
    let call;
@@ -97,13 +109,7 @@ describe('Call', function() {
        global.navigator = {
            mediaDevices: {
                // @ts-ignore Mock
-                getUserMedia: () => {
-                    return {
-                        getTracks: () => [],
-                        getAudioTracks: () => [],
-                        getVideoTracks: () => [],
-                    };
-                },
+                getUserMedia: () => new MockMediaStream("local_stream"),
            },
        };

@@ -114,7 +120,7 @@ describe('Call', function() {
            RTCSessionDescription: {},
            // @ts-ignore Mock
            RTCIceCandidate: {},
-            getUserMedia: {},
+            getUserMedia: () => new MockMediaStream("local_stream"),
        };
        // @ts-ignore Mock
        global.document = {};
@@ -298,4 +304,68 @@ describe('Call', function() {
        // Hangup to stop timers
        call.hangup(CallErrorCode.UserHangup, true);
    });
+
+    it("should map SDPStreamMetadata to feeds", async () => {
+        const callPromise = call.placeVoiceCall();
+        await client.httpBackend.flush();
+        await callPromise;
+
+        call.getOpponentMember = () => {
+            return { userId: "@bob:bar.uk" };
+        };
+
+        await call.onAnswerReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'party_id',
+                    answer: {
+                        sdp: DUMMY_SDP,
+                    },
+                    [SDPStreamMetadataKey]: {
+                        "remote_stream": {
+                            purpose: SDPStreamMetadataPurpose.Usermedia,
+                            audio_muted: true,
+                            video_muted: false,
+                        },
+                    },
+                };
+            },
+        });
+
+        call.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();
+    });
+
+    it("should fallback to replaceTrack() if the other side doesn't support SPDStreamMetadata", async () => {
+        const callPromise = call.placeVoiceCall();
+        await client.httpBackend.flush();
+        await callPromise;
+
+        call.getOpponentMember = () => {
+            return { userId: "@bob:bar.uk" };
+        };
+
+        await call.onAnswerReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'party_id',
+                    answer: {
+                        sdp: DUMMY_SDP,
+                    },
+                };
+            },
+        });
+
+        call.setScreensharingEnabledWithoutMetadataSupport = jest.fn();
+
+        call.setScreensharingEnabled(true);
+        expect(call.setScreensharingEnabledWithoutMetadataSupport).toHaveBeenCalled();
+    });
 });
@@ -0,0 +1,165 @@
+/*
+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.
+*/
+
+// allow camelcase as these are things that go onto the wire
+/* eslint-disable camelcase */
+
+export enum PushRuleActionName {
+    DontNotify = "dont_notify",
+    Notify = "notify",
+    Coalesce = "coalesce",
+}
+
+export enum TweakName {
+    Highlight = "highlight",
+    Sound = "sound",
+}
+
+export type Tweak<N extends TweakName, V> = {
+    set_tweak: N;
+    value: V;
+};
+
+export type TweakHighlight = Tweak<TweakName.Highlight, boolean>;
+export type TweakSound = Tweak<TweakName.Sound, string>;
+
+export type Tweaks = TweakHighlight | TweakSound;
+
+export enum ConditionOperator {
+    ExactEquals = "==",
+    LessThan = "<",
+    GreaterThan = ">",
+    GreaterThanOrEqual = ">=",
+    LessThanOrEqual = "<=",
+}
+
+export type PushRuleAction = Tweaks | PushRuleActionName;
+
+export type MemberCountCondition
+    <N extends number, Op extends ConditionOperator = ConditionOperator.ExactEquals>
+    = `${Op}${N}` | (Op extends ConditionOperator.ExactEquals ? `${N}` : never);
+
+export type AnyMemberCountCondition = MemberCountCondition<number, ConditionOperator>;
+
+export const DMMemberCountCondition: MemberCountCondition<2> = "2";
+
+export function isDmMemberCountCondition(condition: AnyMemberCountCondition): boolean {
+    return condition === "==2" || condition === "2";
+}
+
+export enum ConditionKind {
+    EventMatch = "event_match",
+    ContainsDisplayName = "contains_display_name",
+    RoomMemberCount = "room_member_count",
+    SenderNotificationPermission = "sender_notification_permission",
+}
+
+export interface IPushRuleCondition<N extends ConditionKind | string> {
+    [k: string]: any; // for custom conditions, there can be other fields here
+    kind: N;
+}
+
+export interface IEventMatchCondition extends IPushRuleCondition<ConditionKind.EventMatch> {
+    key: string;
+    pattern: string;
+}
+
+export interface IContainsDisplayNameCondition extends IPushRuleCondition<ConditionKind.ContainsDisplayName> {
+    // no additional fields
+}
+
+export interface IRoomMemberCountCondition extends IPushRuleCondition<ConditionKind.RoomMemberCount> {
+    is: AnyMemberCountCondition;
+}
+
+export interface ISenderNotificationPermissionCondition
+    extends IPushRuleCondition<ConditionKind.SenderNotificationPermission> {
+    key: string;
+}
+
+// XXX: custom conditions are possible but always fail, and break the typescript discriminated union so ignore them here
+// IPushRuleCondition<Exclude<string, ConditionKind>> unfortunately does not resolve this at the time of writing.
+export type PushRuleCondition = IEventMatchCondition
+    | IContainsDisplayNameCondition
+    | IRoomMemberCountCondition
+    | ISenderNotificationPermissionCondition;
+
+export enum PushRuleKind {
+    Override = "override",
+    ContentSpecific = "content",
+    RoomSpecific = "room",
+    SenderSpecific = "sender",
+    Underride = "underride",
+}
+
+export enum RuleId {
+    Master = ".m.rule.master",
+    ContainsDisplayName = ".m.rule.contains_display_name",
+    ContainsUserName = ".m.rule.contains_user_name",
+    AtRoomNotification = ".m.rule.roomnotif",
+    DM = ".m.rule.room_one_to_one",
+    EncryptedDM = ".m.rule.encrypted_room_one_to_one",
+    Message = ".m.rule.message",
+    EncryptedMessage = ".m.rule.encrypted",
+    InviteToSelf = ".m.rule.invite_for_me",
+    MemberEvent = ".m.rule.member_event",
+    IncomingCall = ".m.rule.call",
+    SuppressNotices = ".m.rule.suppress_notices",
+    Tombstone = ".m.rule.tombstone",
+}
+
+export type PushRuleSet = {
+    [k in PushRuleKind]?: IPushRule[];
+};
+
+export interface IPushRule {
+    actions: PushRuleAction[];
+    conditions?: PushRuleCondition[];
+    default: boolean;
+    enabled: boolean;
+    pattern?: string;
+    rule_id: RuleId | string;
+}
+
+export interface IAnnotatedPushRule extends IPushRule {
+    kind: PushRuleKind;
+}
+
+export interface IPushRules {
+    global: PushRuleSet;
+    device?: PushRuleSet;
+}
+
+export interface IPusher {
+    app_display_name: string;
+    app_id: string;
+    data: {
+        format?: string; // TODO: Types
+        url?: string; // TODO: Required if kind==http
+        brand?: string; // TODO: For email notifications only?
+    };
+    device_display_name: string;
+    kind: string; // TODO: Types
+    lang: string;
+    profile_tag?: string;
+    pushkey: string;
+}
+
+export interface IPusherRequest extends IPusher {
+    append?: boolean;
+}
+
+/* eslint-enable camelcase */
@@ -53,6 +53,8 @@ export enum EventType {
    CallReject = "m.call.reject",
    CallSelectAnswer = "m.call.select_answer",
    CallNegotiate = "m.call.negotiate",
+    CallSDPStreamMetadataChanged = "m.call.sdp_stream_metadata_changed",
+    CallSDPStreamMetadataChangedPrefix = "org.matrix.call.sdp_stream_metadata_changed",
    CallReplaces = "m.call.replaces",
    CallAssertedIdentity = "m.call.asserted_identity",
    CallAssertedIdentityPrefix = "org.matrix.call.asserted_identity",
@@ -144,6 +146,33 @@ export const UNSTABLE_MSC3089_LEAF = new UnstableValue("m.leaf", "org.matrix.msc
 */
 export const UNSTABLE_MSC3089_BRANCH = new UnstableValue("m.branch", "org.matrix.msc3089.branch");

+/**
+ * Functional members type for declaring a purpose of room members (e.g. helpful bots).
+ * Note that this reference is UNSTABLE and subject to breaking changes, including its
+ * eventual removal.
+ *
+ * Schema (TypeScript):
+ * {
+ *   service_members?: string[]
+ * }
+ *
+ * Example:
+ * {
+ *   "service_members": [
+ *     "@helperbot:localhost",
+ *     "@reminderbot:alice.tdl"
+ *   ]
+ * }
+ */
+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;
@@ -20,6 +20,12 @@ import "@matrix-org/olm";
 export {};

 declare global {
+    // use `number` as the return type in all cases for global.set{Interval,Timeout},
+    // so we don't accidentally use the methods on NodeJS.Timeout - they only exist in a subset of environments.
+    // The overload for clear{Interval,Timeout} is resolved as expected.
+    function setInterval(handler: TimerHandler, timeout: number, ...arguments: any[]): number;
+    function setTimeout(handler: TimerHandler, timeout: number, ...arguments: any[]): number;
+
    namespace NodeJS {
        interface Global {
            localStorage: Storage;
@@ -27,11 +33,7 @@ declare global {
    }

    interface Window {
-        electron?: Electron;
-    }
-
-    interface Electron {
-        getDesktopCapturerSources(options: GetSourcesOptions): Promise<Array<DesktopCapturerSource>>;
+        webkitAudioContext: typeof AudioContext;
    }

    interface Crypto {
@@ -60,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;
@@ -101,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;
+    }
 }
@@ -39,3 +39,46 @@ export enum Preset {
 }

 export type ResizeMethod = "crop" | "scale";
+
+// TODO move to http-api after TSification
+export interface IAbortablePromise<T> extends Promise<T> {
+    abort(): void;
+}
+
+export type IdServerUnbindResult = "no-support" | "success";
+
+// Knock and private are reserved keywords which are not yet implemented.
+export enum JoinRule {
+    Public = "public",
+    Invite = "invite",
+    /**
+     * @deprecated Reserved keyword. Should not be used. Not yet implemented.
+     */
+    Private = "private",
+    Knock = "knock",
+    Restricted = "restricted",
+}
+
+export enum RestrictedAllowType {
+    RoomMembership = "m.room_membership",
+}
+
+export interface IJoinRuleEventContent {
+    join_rule: JoinRule; // eslint-disable-line camelcase
+    allow?: {
+        type: RestrictedAllowType;
+        room_id: string; // eslint-disable-line camelcase
+    }[];
+}
+
+export enum GuestAccess {
+    CanJoin = "can_join",
+    Forbidden = "forbidden",
+}
+
+export enum HistoryVisibility {
+    Invited = "invited",
+    Joined = "joined",
+    Shared = "shared",
+    WorldReadable = "world_readable",
+}
@@ -15,9 +15,12 @@ limitations under the License.
 */

 import { Callback } from "../client";
+import { IContent } from "../models/event";
 import { Preset, Visibility } from "./partials";
+import { SearchKey } from "./search";
+import { IRoomEventFilter } from "../filter";

-// allow camelcase as these are things go onto the wire
+// allow camelcase as these are things that go onto the wire
 /* eslint-disable camelcase */

 export interface IJoinRoomOpts {
@@ -63,12 +66,12 @@ export interface IGuestAccessOpts {
 }

 export interface ISearchOpts {
-    keys?: string[];
+    keys?: SearchKey[];
    query: string;
 }

 export interface IEventSearchOpts {
-    filter: any; // TODO: Types
+    filter?: IRoomEventFilter;
    term: string;
 }

@@ -82,7 +85,7 @@ export interface IInvite3PID {
 export interface ICreateRoomStateEvent {
    type: string;
    state_key?: string; // defaults to an empty string
-    content: object;
+    content: IContent;
 }

 export interface ICreateRoomOpts {
@@ -104,9 +107,11 @@ export interface IRoomDirectoryOptions {
    server?: string;
    limit?: number;
    since?: string;
-
-    // TODO: Proper types
-    filter?: any & {generic_search_term: string};
+    filter?: {
+        generic_search_term: string;
+    };
+    include_all_networks?: boolean;
+    third_party_instance_id?: string;
 }

 export interface IUploadOpts {
@@ -119,4 +124,19 @@ export interface IUploadOpts {
    progressHandler?: (state: {loaded: number, total: number}) => void;
 }

+export interface IAddThreePidOnlyBody {
+    auth?: {
+        type: string;
+        session?: string;
+    };
+    client_secret: string;
+    sid: string;
+}
+
+export interface IBindThreePidBody {
+    client_secret: string;
+    id_server: string;
+    id_access_token: string;
+    sid: string;
+}
 /* eslint-enable camelcase */
@@ -0,0 +1,118 @@
+/*
+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.
+*/
+
+// Types relating to the /search API
+
+import { IRoomEvent, IStateEvent } from "../sync-accumulator";
+import { IRoomEventFilter } from "../filter";
+import { SearchResult } from "../models/search-result";
+
+/* eslint-disable camelcase */
+export interface IEventWithRoomId extends IRoomEvent {
+    room_id: string;
+}
+
+export interface IStateEventWithRoomId extends IStateEvent {
+    room_id: string;
+}
+
+export interface IMatrixProfile {
+    avatar_url?: string;
+    displayname?: string;
+}
+
+export interface IResultContext {
+    events_before: IEventWithRoomId[];
+    events_after: IEventWithRoomId[];
+    profile_info: Record<string, IMatrixProfile>;
+    start?: string;
+    end?: string;
+}
+
+export interface ISearchResult {
+    rank: number;
+    result: IEventWithRoomId;
+    context: IResultContext;
+}
+
+enum GroupKey {
+    RoomId = "room_id",
+    Sender = "sender",
+}
+
+export interface IResultRoomEvents {
+    count: number;
+    highlights: string[];
+    results: ISearchResult[];
+    state?: { [roomId: string]: IStateEventWithRoomId[] };
+    groups?: {
+        [groupKey in GroupKey]: {
+            [value: string]: {
+                next_batch?: string;
+                order: number;
+                results: string[];
+            };
+        };
+    };
+    next_batch?: string;
+}
+
+interface IResultCategories {
+    room_events: IResultRoomEvents;
+}
+
+export type SearchKey = "content.body" | "content.name" | "content.topic";
+
+export enum SearchOrderBy {
+    Recent = "recent",
+    Rank = "rank",
+}
+
+export interface ISearchRequestBody {
+    search_categories: {
+        room_events: {
+            search_term: string;
+            keys?: SearchKey[];
+            filter?: IRoomEventFilter;
+            order_by?: SearchOrderBy;
+            event_context?: {
+                before_limit?: number;
+                after_limit?: number;
+                include_profile?: boolean;
+            };
+            include_state?: boolean;
+            groupings?: {
+                group_by: {
+                    key: GroupKey;
+                }[];
+            };
+        };
+    };
+}
+
+export interface ISearchResponse {
+    search_categories: IResultCategories;
+}
+
+export interface ISearchResults {
+    _query?: ISearchRequestBody;
+    results: SearchResult[];
+    highlights: string[];
+    count?: number;
+    next_batch?: string;
+    pendingRequest?: Promise<ISearchResults>;
+}
+/* eslint-enable camelcase */
@@ -0,0 +1,60 @@
+/*
+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 { IPublicRoomsChunkRoom } from "../client";
+import { RoomType } from "./event";
+import { IStrippedState } from "../sync-accumulator";
+
+// Types relating to Rooms of type `m.space` and related APIs
+
+/* eslint-disable camelcase */
+/** @deprecated Use hierarchy instead where possible. */
+export interface ISpaceSummaryRoom extends IPublicRoomsChunkRoom {
+    num_refs: number;
+    room_type: string;
+}
+
+/** @deprecated Use hierarchy instead where possible. */
+export interface ISpaceSummaryEvent {
+    room_id: string;
+    event_id: string;
+    origin_server_ts: number;
+    type: string;
+    state_key: string;
+    sender: string;
+    content: {
+        order?: string;
+        suggested?: boolean;
+        auto_join?: boolean;
+        via?: string[];
+    };
+}
+
+export interface IHierarchyRelation extends IStrippedState {
+    room_id: string;
+    origin_server_ts: number;
+    content: {
+        order?: string;
+        suggested?: boolean;
+        via?: string[];
+    };
+}
+
+export interface IHierarchyRoom extends IPublicRoomsChunkRoom {
+    room_type?: RoomType | string;
+    children_state: IHierarchyRelation[];
+}
+/* eslint-enable camelcase */
@@ -0,0 +1,40 @@
+/*
+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 { IdServerUnbindResult } from "./partials";
+
+// Types relating to Synapse Admin APIs
+
+/* eslint-disable camelcase */
+export interface ISynapseAdminWhoisResponse {
+    user_id: string;
+    devices: {
+        [deviceId: string]: {
+            sessions: {
+                connections: {
+                    ip: string;
+                    last_seen: number; // millis since epoch
+                    user_agent: string;
+                }[];
+            }[];
+        };
+    };
+}
+
+export interface ISynapseAdminDeactivateResponse {
+    id_server_unbind_result: IdServerUnbindResult;
+}
+/* eslint-enable camelcase */
@@ -0,0 +1,29 @@
+/*
+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.
+*/
+
+export enum ThreepidMedium {
+    Email = "email",
+    Phone = "msisdn",
+}
+
+// TODO: Are these types universal, or specific to just /account/3pid?
+export interface IThreepid {
+    medium: ThreepidMedium;
+    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,
                        });
@@ -17,6 +17,8 @@ limitations under the License.

 /** @module ContentHelpers */

+import { MsgType } from "./@types/event";
+
 /**
 * Generates the content for a HTML Message event
 * @param {string} body the plaintext body of the message
@@ -25,7 +27,7 @@ limitations under the License.
 */
 export function makeHtmlMessage(body: string, htmlBody: string) {
    return {
-        msgtype: "m.text",
+        msgtype: MsgType.Text,
        format: "org.matrix.custom.html",
        body: body,
        formatted_body: htmlBody,
@@ -40,7 +42,7 @@ export function makeHtmlMessage(body: string, htmlBody: string) {
 */
 export function makeHtmlNotice(body: string, htmlBody: string) {
    return {
-        msgtype: "m.notice",
+        msgtype: MsgType.Notice,
        format: "org.matrix.custom.html",
        body: body,
        formatted_body: htmlBody,
@@ -55,7 +57,7 @@ export function makeHtmlNotice(body: string, htmlBody: string) {
 */
 export function makeHtmlEmote(body: string, htmlBody: string) {
    return {
-        msgtype: "m.emote",
+        msgtype: MsgType.Emote,
        format: "org.matrix.custom.html",
        body: body,
        formatted_body: htmlBody,
@@ -69,7 +71,7 @@ export function makeHtmlEmote(body: string, htmlBody: string) {
 */
 export function makeTextMessage(body: string) {
    return {
-        msgtype: "m.text",
+        msgtype: MsgType.Text,
        body: body,
    };
 }
@@ -81,7 +83,7 @@ export function makeTextMessage(body: string) {
 */
 export function makeNotice(body: string) {
    return {
-        msgtype: "m.notice",
+        msgtype: MsgType.Notice,
        body: body,
    };
 }
@@ -93,7 +95,7 @@ export function makeNotice(body: string) {
 */
 export function makeEmoteMessage(body: string) {
    return {
-        msgtype: "m.emote",
+        msgtype: MsgType.Emote,
        body: body,
    };
 }
@@ -28,10 +28,11 @@ import { decryptAES, encryptAES } from './aes';
 import { PkSigning } from "@matrix-org/olm";
 import { DeviceInfo } from "./deviceinfo";
 import { SecretStorage } from "./SecretStorage";
-import { CryptoStore, ICrossSigningKey, ISignedKey, MatrixClient } from "../client";
+import { ICrossSigningKey, ISignedKey, MatrixClient } from "../client";
 import { OlmDevice } from "./OlmDevice";
 import { ICryptoCallbacks } from "../matrix";
 import { ISignatures } from "../@types/signed";
+import { CryptoStore } from "./store/base";

 const KEY_REQUEST_TIMEOUT_MS = 1000 * 60;

@@ -47,6 +48,12 @@ export interface ICacheCallbacks {
    storeCrossSigningKeyCache?(type: string, key: Uint8Array): Promise<void>;
 }

+export interface ICrossSigningInfo {
+    keys: Record<string, ICrossSigningKey>;
+    firstUse: boolean;
+    crossSigningVerifiedBefore: boolean;
+}
+
 export class CrossSigningInfo extends EventEmitter {
    public keys: Record<string, ICrossSigningKey> = {};
    public firstUse = true;
@@ -75,7 +82,7 @@ export class CrossSigningInfo extends EventEmitter {
        super();
    }

-    public static fromStorage(obj: object, userId: string): CrossSigningInfo {
+    public static fromStorage(obj: ICrossSigningInfo, userId: string): CrossSigningInfo {
        const res = new CrossSigningInfo(userId);
        for (const prop in obj) {
            if (obj.hasOwnProperty(prop)) {
@@ -85,7 +92,7 @@ export class CrossSigningInfo extends EventEmitter {
        return res;
    }

-    public toStorage(): object {
+    public toStorage(): ICrossSigningInfo {
        return {
            keys: this.keys,
            firstUse: this.firstUse,
@@ -706,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 {
@@ -719,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',
@@ -732,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.
 *
@@ -739,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;

@@ -774,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,
@@ -794,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...");
@@ -807,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) => {
@@ -24,12 +24,13 @@ import { EventEmitter } from 'events';

 import { logger } from '../logger';
 import { DeviceInfo, IDevice } from './deviceinfo';
-import { CrossSigningInfo } from './CrossSigning';
+import { CrossSigningInfo, ICrossSigningInfo } from './CrossSigning';
 import * as olmlib from './olmlib';
 import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
 import { chunkPromises, defer, IDeferred, sleep } from '../utils';
-import { MatrixClient, CryptoStore } from "../client";
+import { MatrixClient } from "../client";
 import { OlmDevice } from "./OlmDevice";
+import { CryptoStore } from "./store/base";

 /* State transition diagram for DeviceList.deviceTrackingStatus
 *
@@ -52,7 +53,7 @@ import { OlmDevice } from "./OlmDevice";
 */

 // constants for DeviceList.deviceTrackingStatus
-enum TrackingStatus {
+export enum TrackingStatus {
    NotTracked,
    PendingDownload,
    DownloadInProgress,
@@ -65,32 +66,22 @@ export type DeviceInfoMap = Record<string, Record<string, DeviceInfo>>;
 * @alias module:crypto/DeviceList
 */
 export class DeviceList extends EventEmitter {
-    // userId -> {
-    //     deviceId -> {
-    //         [device info]
-    //     }
-    // }
-    private devices: Record<string, Record<string, IDevice>> = {};
+    private devices: { [userId: string]: { [deviceId: string]: IDevice } } = {};

-    // userId -> {
-    //     [key info]
-    // }
-    public crossSigningInfo: Record<string, object> = {};
+    public crossSigningInfo: { [userId: string]: ICrossSigningInfo } = {};

    // map of identity keys to the user who owns it
    private userByIdentityKey: Record<string, string> = {};

    // which users we are tracking device status for.
-    // userId -> TRACKING_STATUS_*
-    private deviceTrackingStatus: Record<string, TrackingStatus> = {}; // loaded from storage in load()
+    private deviceTrackingStatus: { [userId: string]: TrackingStatus } = {}; // loaded from storage in load()

    // The 'next_batch' sync token at the point the data was written,
    // ie. a token representing the point immediately after the
    // moment represented by the snapshot in the db.
    private syncToken: string = null;

-    // userId -> promise
-    private keyDownloadsInProgressByUser: Record<string, Promise<void>> = {};
+    private keyDownloadsInProgressByUser: { [userId: string]: Promise<void> } = {};

    // Set whenever changes are made other than setting the sync token
    private dirty = false;
@@ -102,7 +93,7 @@ export class DeviceList extends EventEmitter {
    // The time the save is scheduled for
    private savePromiseTime: number = null;
    // The timer used to delay the save
-    private saveTimer: NodeJS.Timeout = null;
+    private saveTimer: number = null;
    // True if we have fetched data from the server or loaded a non-empty
    // set of device data from the store
    private hasFetched: boolean = null;
@@ -375,7 +366,7 @@ export class DeviceList extends EventEmitter {
        return CrossSigningInfo.fromStorage(this.crossSigningInfo[userId], userId);
    }

-    public storeCrossSigningForUser(userId: string, info: CrossSigningInfo): void {
+    public storeCrossSigningForUser(userId: string, info: ICrossSigningInfo): void {
        this.crossSigningInfo[userId] = info;
        this.dirty = true;
    }
@@ -603,7 +594,7 @@ export class DeviceList extends EventEmitter {
        }
    }

-    public setRawStoredCrossSigningForUser(userId: string, info: object): void {
+    public setRawStoredCrossSigningForUser(userId: string, info: ICrossSigningInfo): void {
        this.crossSigningInfo[userId] = info;
    }

@@ -864,9 +855,7 @@ class DeviceListUpdateSerialiser {

                crossSigning.setKeys(crossSigningResponse);

-                this.deviceList.setRawStoredCrossSigningForUser(
-                    userId, crossSigning.toStorage(),
-                );
+                this.deviceList.setRawStoredCrossSigningForUser(userId, crossSigning.toStorage());

                // NB. Unlike most events in the js-sdk, this one is internal to the
                // js-sdk and is not re-emitted
@@ -1,3 +1,19 @@
+/*
+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 { logger } from "../logger";
 import { MatrixEvent } from "../models/event";
 import { EventEmitter } from "events";
@@ -43,7 +59,7 @@ export class EncryptionSetupBuilder {
     * @param {Object.<String, MatrixEvent>} accountData pre-existing account data, will only be read, not written.
     * @param {CryptoCallbacks} delegateCryptoCallbacks crypto callbacks to delegate to if the key isn't in cache yet
     */
-    constructor(accountData: Record<string, MatrixEvent>, delegateCryptoCallbacks: ICryptoCallbacks) {
+    constructor(accountData: Record<string, MatrixEvent>, delegateCryptoCallbacks?: ICryptoCallbacks) {
        this.accountDataClientAdapter = new AccountDataClientAdapter(accountData);
        this.crossSigningCallbacks = new CrossSigningCallbacks();
        this.ssssCryptoCallbacks = new SSSSCryptoCallbacks(delegateCryptoCallbacks);
@@ -109,8 +125,8 @@ export class EncryptionSetupBuilder {
     * @param {Object} content
     * @return {Promise}
     */
-    public setAccountData(type: string, content: object): Promise<void> {
-        return this.accountDataClientAdapter.setAccountData(type, content);
+    public async setAccountData(type: string, content: object): Promise<void> {
+        await this.accountDataClientAdapter.setAccountData(type, content);
    }

    /**
@@ -284,7 +300,7 @@ class AccountDataClientAdapter extends EventEmitter {
     * @param {Object} content
     * @return {Promise}
     */
-    public setAccountData(type: string, content: any): Promise<void> {
+    public setAccountData(type: string, content: any): Promise<{}> {
        const lastEvent = this.values.get(type);
        this.values.set(type, content);
        // ensure accountData is emitted on the next tick,
@@ -293,6 +309,7 @@ class AccountDataClientAdapter extends EventEmitter {
        return Promise.resolve().then(() => {
            const event = new MatrixEvent({ type, content });
            this.emit("accountData", event, lastEvent);
+            return {};
        });
    }
 }
@@ -334,12 +351,12 @@ class CrossSigningCallbacks implements ICryptoCallbacks, ICacheCallbacks {
 class SSSSCryptoCallbacks {
    private readonly privateKeys = new Map<string, Uint8Array>();

-    constructor(private readonly delegateCryptoCallbacks: ICryptoCallbacks) {}
+    constructor(private readonly delegateCryptoCallbacks?: ICryptoCallbacks) {}

    public async getSecretStorageKey(
        { keys }: { keys: Record<string, ISecretStorageKeyInfo> },
        name: string,
-    ): Promise<[string, Uint8Array]> {
+    ): Promise<[string, Uint8Array]|null> {
        for (const keyId of Object.keys(keys)) {
            const privateKey = this.privateKeys.get(keyId);
            if (privateKey) {
@@ -348,7 +365,7 @@ class SSSSCryptoCallbacks {
        }
        // if we don't have the key cached yet, ask
        // for it to the general crypto callbacks and cache it
-        if (this.delegateCryptoCallbacks) {
+        if (this?.delegateCryptoCallbacks?.getSecretStorageKey) {
            const result = await this.delegateCryptoCallbacks.
                getSecretStorageKey({ keys }, name);
            if (result) {
@@ -357,6 +374,7 @@ class SSSSCryptoCallbacks {
            }
            return result;
        }
+        return null;
    }

    public addPrivateKey(keyId: string, keyInfo: ISecretStorageKeyInfo, privKey: Uint8Array): void {
@@ -15,9 +15,9 @@ limitations under the License.
 */

 import { logger } from '../logger';
-import { CryptoStore, MatrixClient } from "../client";
+import { MatrixClient } from "../client";
 import { IRoomKeyRequestBody, IRoomKeyRequestRecipient } from "./index";
-import { OutgoingRoomKeyRequest } from './store/base';
+import { CryptoStore, OutgoingRoomKeyRequest } from './store/base';
 import { EventType } from "../@types/event";

 /**
@@ -78,7 +78,7 @@ export enum RoomKeyRequestState {
 export class OutgoingRoomKeyRequestManager {
    // handle for the delayed call to sendOutgoingRoomKeyRequests. Non-null
    // if the callback has been set, or if it is still running.
-    private sendOutgoingRoomKeyRequestsTimer: NodeJS.Timeout = null;
+    private sendOutgoingRoomKeyRequestsTimer: number = null;

    // sanity check to ensure that we don't end up with two concurrent runs
    // of sendOutgoingRoomKeyRequests
@@ -137,9 +137,7 @@ export class OutgoingRoomKeyRequestManager {
        recipients: IRoomKeyRequestRecipient[],
        resend = false,
    ): Promise<void> {
-        const req = await this.cryptoStore.getOutgoingRoomKeyRequest(
-            requestBody,
-        );
+        const req = await this.cryptoStore.getOutgoingRoomKeyRequest(requestBody);
        if (!req) {
            await this.cryptoStore.getOrAddOutgoingRoomKeyRequest({
                requestBody: requestBody,
@@ -237,10 +235,10 @@ export class OutgoingRoomKeyRequestManager {
     * @returns {Promise} resolves when the request has been updated in our
     *    pending list.
     */
-    public cancelRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<void> {
+    public cancelRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<unknown> {
        return this.cryptoStore.getOutgoingRoomKeyRequest(
            requestBody,
-        ).then((req) => {
+        ).then((req): unknown => {
            if (!req) {
                // no request was made for this key
                return;
@@ -263,9 +261,7 @@ export class OutgoingRoomKeyRequestManager {
                        'deleting unnecessary room key request for ' +
                        stringifyRequestBody(requestBody),
                    );
-                    return this.cryptoStore.deleteOutgoingRoomKeyRequest(
-                        req.requestId, RoomKeyRequestState.Unsent,
-                    );
+                    return this.cryptoStore.deleteOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Unsent);

                case RoomKeyRequestState.Sent: {
                    // send a cancellation.
@@ -325,7 +321,7 @@ export class OutgoingRoomKeyRequestManager {
     * @return {Promise} resolves to a list of all the
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
     */
-    public getOutgoingSentRoomKeyRequest(userId: string, deviceId: string): OutgoingRoomKeyRequest[] {
+    public getOutgoingSentRoomKeyRequest(userId: string, deviceId: string): Promise<OutgoingRoomKeyRequest[]> {
        return this.cryptoStore.getOutgoingRoomKeyRequestsByTarget(userId, deviceId, [RoomKeyRequestState.Sent]);
    }

@@ -366,7 +362,7 @@ export class OutgoingRoomKeyRequestManager {
            });
        };

-        this.sendOutgoingRoomKeyRequestsTimer = global.setTimeout(
+        this.sendOutgoingRoomKeyRequestsTimer = setTimeout(
            startSendingOutgoingRoomKeyRequests,
            SEND_KEY_REQUESTS_DELAY_MS,
        );
@@ -415,7 +411,7 @@ export class OutgoingRoomKeyRequestManager {
    }

    // given a RoomKeyRequest, send it and update the request record
-    private sendOutgoingRoomKeyRequest(req: OutgoingRoomKeyRequest): Promise<void> {
+    private sendOutgoingRoomKeyRequest(req: OutgoingRoomKeyRequest): Promise<unknown> {
        logger.log(
            `Requesting keys for ${stringifyRequestBody(req.requestBody)}` +
            ` from ${stringifyRecipientList(req.recipients)}` +
@@ -441,7 +437,7 @@ export class OutgoingRoomKeyRequestManager {

    // Given a RoomKeyRequest, cancel it and delete the request record unless
    // andResend is set, in which case transition to UNSENT.
-    private sendOutgoingRoomKeyRequestCancellation(req: OutgoingRoomKeyRequest, andResend = false): Promise<void> {
+    private sendOutgoingRoomKeyRequestCancellation(req: OutgoingRoomKeyRequest, andResend = false): Promise<unknown> {
        logger.log(
            `Sending cancellation for key request for ` +
            `${stringifyRequestBody(req.requestBody)} to ` +
@@ -20,14 +20,14 @@ limitations under the License.
 * Manages the list of encrypted rooms
 */

+import { CryptoStore } from './store/base';
 import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
-import { CryptoStore } from "../client";

 /* eslint-disable camelcase */
-interface IRoomEncryption {
+export interface IRoomEncryption {
    algorithm: string;
-    rotation_period_ms: number;
-    rotation_period_msgs: number;
+    rotation_period_ms?: number;
+    rotation_period_msgs?: number;
 }
 /* eslint-enable camelcase */

@@ -37,9 +37,9 @@ export interface ISecretRequest {

 export interface IAccountDataClient extends EventEmitter {
    // Subset of MatrixClient (which also uses any for the event content)
-    getAccountDataFromServer: (eventType: string) => Promise<any>;
+    getAccountDataFromServer: (eventType: string) => Promise<Record<string, any>>;
    getAccountData: (eventType: string) => MatrixEvent;
-    setAccountData: (eventType: string, content: any) => Promise<void>;
+    setAccountData: (eventType: string, content: any) => Promise<{}>;
 }

 interface ISecretRequestInternal {
@@ -174,7 +174,7 @@ export class SecretStorage {
     *     the form [keyId, keyInfo].  Otherwise, null is returned.
     *     XXX: why is this an array when addKey returns an object?
     */
-    public async getKey(keyId: string): Promise<SecretStorageKeyTuple> {
+    public async getKey(keyId: string): Promise<SecretStorageKeyTuple | null> {
        if (!keyId) {
            keyId = await this.getDefaultKeyId();
        }
@@ -184,7 +184,7 @@ export class SecretStorage {

        const keyInfo = await this.accountDataAdapter.getAccountDataFromServer(
            "m.secret_storage.key." + keyId,
-        );
+        ) as ISecretStorageKeyInfo;
        return keyInfo ? [keyId, keyInfo] : null;
    }

@@ -248,7 +248,7 @@ export class SecretStorage {
            // get key information from key storage
            const keyInfo = await this.accountDataAdapter.getAccountDataFromServer(
                "m.secret_storage.key." + keyId,
-            );
+            ) as ISecretStorageKeyInfo;
            if (!keyInfo) {
                throw new Error("Unknown key: " + keyId);
            }
@@ -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;
 }

 /**
@@ -50,12 +51,12 @@ async function encryptNode(data: string, key: Uint8Array, name: string, ivStr?:
        iv = decodeBase64(ivStr);
    } else {
        iv = crypto.randomBytes(16);
-    }

-    // clear bit 63 of the IV to stop us hitting the 64-bit counter boundary
-    // (which would mean we wouldn't be able to decrypt on Android). The loss
-    // of a single bit of iv is a price we have to pay.
-    iv[8] &= 0x7f;
+        // clear bit 63 of the IV to stop us hitting the 64-bit counter boundary
+        // (which would mean we wouldn't be able to decrypt on Android). The loss
+        // of a single bit of iv is a price we have to pay.
+        iv[8] &= 0x7f;
+    }

    const [aesKey, hmacKey] = deriveKeysNode(key, name);

@@ -137,12 +138,12 @@ async function encryptBrowser(data: string, key: Uint8Array, name: string, ivStr
    } else {
        iv = new Uint8Array(16);
        window.crypto.getRandomValues(iv);
-    }

-    // clear bit 63 of the IV to stop us hitting the 64-bit counter boundary
-    // (which would mean we wouldn't be able to decrypt on Android). The loss
-    // of a single bit of iv is a price we have to pay.
-    iv[8] &= 0x7f;
+        // clear bit 63 of the IV to stop us hitting the 64-bit counter boundary
+        // (which would mean we wouldn't be able to decrypt on Android). The loss
+        // of a single bit of iv is a price we have to pay.
+        iv[8] &= 0x7f;
+    }

    const [aesKey, hmacKey] = await deriveKeysBrowser(key, name);
    const encodedData = new TextEncoder().encode(data);
@@ -26,6 +26,7 @@ import { OlmDevice } from "../OlmDevice";
 import { MatrixEvent, RoomMember } from "../..";
 import { Crypto, IEventDecryptionResult, IMegolmSessionData, IncomingRoomKeyRequest } from "..";
 import { DeviceInfo } from "../deviceinfo";
+import { IRoomEncryption } from "../RoomList";

 /**
 * map of registered encryption algorithm classes. A map from string to {@link
@@ -52,7 +53,7 @@ interface IParams {
    olmDevice: OlmDevice;
    baseApis: MatrixClient;
    roomId: string;
-    config: object;
+    config: IRoomEncryption & object;
 }

 /**
@@ -61,13 +61,13 @@ interface IBlockedMap {
    };
 }

-interface IOlmDevice<T = DeviceInfo> {
+export interface IOlmDevice<T = DeviceInfo> {
    userId: string;
    deviceInfo: T;
 }

 /* eslint-disable camelcase */
-interface IOutboundGroupSessionKey {
+export interface IOutboundGroupSessionKey {
    chain_index: number;
    key: string;
 }
@@ -101,6 +101,13 @@ interface IPayload extends Partial<IMessage> {
 }
 /* eslint-enable camelcase */

+interface SharedWithData {
+    // The identity key of the device we shared with
+    deviceKey: string;
+    // The message index of the ratchet we shared with that device
+    messageIndex: number;
+}
+
 /**
 * @private
 * @constructor
@@ -115,12 +122,12 @@ interface IPayload extends Partial<IMessage> {
 *
 * @property {object} sharedWithDevices
 *    devices with which we have shared the session key
- *        userId -> {deviceId -> msgindex}
+ *        userId -> {deviceId -> SharedWithData}
 */
 class OutboundSessionInfo {
    public useCount = 0;
    public creationTime: number;
-    public sharedWithDevices: Record<string, Record<string, number>> = {};
+    public sharedWithDevices: Record<string, Record<string, SharedWithData>> = {};
    public blockedDevicesNotified: Record<string, Record<string, boolean>> = {};

    constructor(public readonly sessionId: string, public readonly sharedHistory = false) {
@@ -150,11 +157,11 @@ class OutboundSessionInfo {
        return false;
    }

-    public markSharedWithDevice(userId: string, deviceId: string, chainIndex: number): void {
+    public markSharedWithDevice(userId: string, deviceId: string, deviceKey: string, chainIndex: number): void {
        if (!this.sharedWithDevices[userId]) {
            this.sharedWithDevices[userId] = {};
        }
-        this.sharedWithDevices[userId][deviceId] = chainIndex;
+        this.sharedWithDevices[userId][deviceId] = { deviceKey, messageIndex: chainIndex };
    }

    public markNotifiedBlockedDevice(userId: string, deviceId: string): void {
@@ -572,6 +579,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
        payload: IPayload,
    ): Promise<void> {
        const contentMap = {};
+        const deviceInfoByDeviceId = new Map<string, DeviceInfo>();

        const promises = [];
        for (let i = 0; i < userDeviceMap.length; i++) {
@@ -584,6 +592,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
            const userId = val.userId;
            const deviceInfo = val.deviceInfo;
            const deviceId = deviceInfo.deviceId;
+            deviceInfoByDeviceId.set(deviceId, deviceInfo);

            if (!contentMap[userId]) {
                contentMap[userId] = {};
@@ -636,7 +645,10 @@ class MegolmEncryption extends EncryptionAlgorithm {
                for (const userId of Object.keys(contentMap)) {
                    for (const deviceId of Object.keys(contentMap[userId])) {
                        session.markSharedWithDevice(
-                            userId, deviceId, chainIndex,
+                            userId,
+                            deviceId,
+                            deviceInfoByDeviceId.get(deviceId).getIdentityKey(),
+                            chainIndex,
                        );
                    }
                }
@@ -719,8 +731,8 @@ class MegolmEncryption extends EncryptionAlgorithm {
            logger.debug(`megolm session ${sessionId} never shared with user ${userId}`);
            return;
        }
-        const sentChainIndex = obSessionInfo.sharedWithDevices[userId][device.deviceId];
-        if (sentChainIndex === undefined) {
+        const sessionSharedData = obSessionInfo.sharedWithDevices[userId][device.deviceId];
+        if (sessionSharedData === undefined) {
            logger.debug(
                "megolm session ID " + sessionId + " never shared with device " +
                userId + ":" + device.deviceId,
@@ -728,10 +740,18 @@ class MegolmEncryption extends EncryptionAlgorithm {
            return;
        }

+        if (sessionSharedData.deviceKey !== device.getIdentityKey()) {
+            logger.warn(
+                `Session has been shared with device ${device.deviceId} but with identity ` +
+                `key ${sessionSharedData.deviceKey}. Key is now ${device.getIdentityKey()}!`,
+            );
+            return;
+        }
+
        // get the key from the inbound session: the outbound one will already
        // have been ratcheted to the next chain index.
        const key = await this.olmDevice.getInboundGroupSessionKey(
-            this.roomId, senderKey, sessionId, sentChainIndex,
+            this.roomId, senderKey, sessionId, sessionSharedData.messageIndex,
        );

        if (!key) {
@@ -882,14 +902,12 @@ class MegolmEncryption extends EncryptionAlgorithm {
            const deviceId = deviceInfo.deviceId;

            session.markSharedWithDevice(
-                userId, deviceId, key.chain_index,
+                userId, deviceId, deviceInfo.getIdentityKey(), key.chain_index,
            );
        }

        const filteredFailedDevices =
-            await this.olmDevice.filterOutNotifiedErrorDevices(
-                failedDevices,
-            );
+            await this.olmDevice.filterOutNotifiedErrorDevices(failedDevices);
        logger.debug(
            `Filtered down to ${filteredFailedDevices.length} error devices ` +
            `in ${this.roomId}`,
@@ -1391,7 +1409,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 {
@@ -31,7 +31,7 @@ import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
 import { encodeRecoveryKey } from './recoverykey';
 import { encryptAES, decryptAES, calculateKeyCheck } from './aes';
 import { getCrypto } from '../utils';
-import { ICurve25519AuthData, IAes256AuthData, IKeyBackupInfo } from "./keybackup";
+import { ICurve25519AuthData, IAes256AuthData, IKeyBackupInfo, IKeyBackupSession } from "./keybackup";
 import { UnstableValue } from "../NamespacedValue";

 const KEY_BACKUP_KEYS_PER_REQUEST = 200;
@@ -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 {
@@ -85,12 +87,22 @@ interface BackupAlgorithmClass {
 interface BackupAlgorithm {
    untrusted: boolean;
    encryptSession(data: Record<string, any>): Promise<any>;
-    decryptSessions(ciphertexts: Record<string, any>): Promise<Record<string, any>[]>;
+    decryptSessions(ciphertexts: Record<string, IKeyBackupSession>): Promise<Record<string, any>[]>;
    authData: AuthData;
    keyMatches(key: ArrayLike<number>): Promise<boolean>;
    free(): void;
 }

+export interface IKeyBackup {
+    rooms: {
+        [roomId: string]: {
+            sessions: {
+                [sessionId: string]: IKeyBackupSession;
+            };
+        };
+    };
+}
+
 /**
 * Manages the key backup.
 */
@@ -464,11 +476,11 @@ export class BackupManager {
        let remaining = await this.baseApis.crypto.cryptoStore.countSessionsNeedingBackup();
        this.baseApis.crypto.emit("crypto.keyBackupSessionsRemaining", remaining);

-        const data = {};
+        const rooms: IKeyBackup["rooms"] = {};
        for (const session of sessions) {
            const roomId = session.sessionData.room_id;
-            if (data[roomId] === undefined) {
-                data[roomId] = { sessions: {} };
+            if (rooms[roomId] === undefined) {
+                rooms[roomId] = { sessions: {} };
            }

            const sessionData = await this.baseApis.crypto.olmDevice.exportInboundGroupSession(
@@ -487,7 +499,7 @@ export class BackupManager {
            );
            const verified = this.baseApis.crypto.checkDeviceInfoTrust(userId, device).isVerified();

-            data[roomId]['sessions'][session.sessionId] = {
+            rooms[roomId]['sessions'][session.sessionId] = {
                first_message_index: sessionData.first_known_index,
                forwarded_count: forwardedCount,
                is_verified: verified,
@@ -495,10 +507,7 @@ export class BackupManager {
            };
        }

-        await this.baseApis.sendKeyBackup(
-            undefined, undefined, this.backupInfo.version,
-            { rooms: data },
-        );
+        await this.baseApis.sendKeyBackup(undefined, undefined, this.backupInfo.version, { rooms });

        await this.baseApis.crypto.cryptoStore.unmarkSessionsNeedingBackup(sessions);
        remaining = await this.baseApis.crypto.cryptoStore.countSessionsNeedingBackup();
@@ -636,7 +645,9 @@ export class Curve25519 implements BackupAlgorithm {
        return this.publicKey.encrypt(JSON.stringify(plainText));
    }

-    public async decryptSessions(sessions: Record<string, Record<string, any>>): Promise<Record<string, any>[]> {
+    public async decryptSessions(
+        sessions: Record<string, IKeyBackupSession>,
+    ): Promise<Record<string, any>[]> {
        const privKey = await this.getKey();
        const decryption = new global.Olm.PkDecryption();
        try {
@@ -766,14 +777,12 @@ export class Aes256 implements BackupAlgorithm {
        return await encryptAES(JSON.stringify(plainText), this.key, data.session_id);
    }

-    async decryptSessions(sessions: Record<string, any>): Promise<Record<string, any>[]> {
+    async decryptSessions(sessions: Record<string, IKeyBackupSession>): Promise<Record<string, any>[]> {
        const keys = [];

        for (const [sessionId, sessionData] of Object.entries(sessions)) {
            try {
-                const decrypted = JSON.parse(await decryptAES(
-                    sessionData.session_data, this.key, sessionId,
-                ));
+                const decrypted = JSON.parse(await decryptAES(sessionData.session_data, this.key, sessionId));
                decrypted.session_id = sessionId;
                keys.push(decrypted);
            } catch (e) {
@@ -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>>;
@@ -36,7 +37,7 @@ export interface IDehydratedDeviceKeyInfo {
    passphrase?: string;
 }

-interface DeviceKeys {
+export interface IDeviceKeys {
    algorithms: Array<string>;
    device_id: string; // eslint-disable-line camelcase
    user_id: string; // eslint-disable-line camelcase
@@ -44,7 +45,7 @@ interface DeviceKeys {
    signatures?: Signatures;
 }

-export interface OneTimeKey {
+export interface IOneTimeKey {
    key: string;
    fallback?: boolean;
    signatures?: Signatures;
@@ -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);
@@ -222,7 +223,7 @@ export class DehydrationManager {
            // send the keys to the server
            const deviceId = dehydrateResult.device_id;
            logger.log("Preparing device keys", deviceId);
-            const deviceKeys: DeviceKeys = {
+            const deviceKeys: IDeviceKeys = {
                algorithms: this.crypto.supportedAlgorithms,
                device_id: deviceId,
                user_id: this.crypto.userId,
@@ -244,7 +245,7 @@ export class DehydrationManager {
            logger.log("Preparing one-time keys");
            const oneTimeKeys = {};
            for (const [keyId, key] of Object.entries(otks.curve25519)) {
-                const k: OneTimeKey = { key };
+                const k: IOneTimeKey = { key };
                const signature = account.sign(anotherjson.stringify(k));
                k.signatures = {
                    [this.crypto.userId]: {
@@ -257,7 +258,7 @@ export class DehydrationManager {
            logger.log("Preparing fallback keys");
            const fallbackKeys = {};
            for (const [keyId, key] of Object.entries(fallbacks.curve25519)) {
-                const k: OneTimeKey = { key, fallback: true };
+                const k: IOneTimeKey = { key, fallback: true };
                const signature = account.sign(anotherjson.stringify(k));
                k.signatures = {
                    [this.crypto.userId]: {
@@ -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";
@@ -44,7 +44,7 @@ import { IAddSecretStorageKeyOpts, 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';
-import { SAS } from './verification/SAS';
+import { SAS as SASVerification } from './verification/SAS';
 import { keyFromPassphrase } from './key_passphrase';
 import { decodeRecoveryKey, encodeRecoveryKey } from './recoverykey';
 import { VerificationRequest } from "./verification/request/VerificationRequest";
@@ -53,24 +53,26 @@ import { ToDeviceChannel, ToDeviceRequests } from "./verification/request/ToDevi
 import { IllegalMethod } from "./verification/IllegalMethod";
 import { KeySignatureUploadError } from "../errors";
 import { decryptAES, encryptAES, calculateKeyCheck } from './aes';
-import { DehydrationManager } from './dehydration';
+import { DehydrationManager, IDeviceKeys, IOneTimeKey } from './dehydration';
 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 { MatrixClient, IKeysUploadResponse, SessionStore, CryptoStore, ISignedKey } from "../client";
+import { MatrixClient, IKeysUploadResponse, SessionStore, ISignedKey } from "../client";
 import type { EncryptionAlgorithm, DecryptionAlgorithm } from "./algorithms/base";
-import type { RoomList } from "./RoomList";
+import type { IRoomEncryption, RoomList } from "./RoomList";
 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;

 const defaultVerificationMethods = {
    [ReciprocateQRCode.NAME]: ReciprocateQRCode,
-    [SAS.NAME]: SAS,
+    [SASVerification.NAME]: SASVerification,

    // These two can't be used for actual verification, but we do
    // need to be able to define them here for the verification flows
@@ -82,11 +84,14 @@ const defaultVerificationMethods = {
 /**
 * verification method names
 */
+// legacy export identifier
 export const verificationMethods = {
    RECIPROCATE_QR_CODE: ReciprocateQRCode.NAME,
-    SAS: SAS.NAME,
+    SAS: SASVerification.NAME,
 };

+export type VerificationMethod = keyof typeof verificationMethods | string;
+
 export function isCryptoAvailable(): boolean {
    return Boolean(global.Olm);
 }
@@ -94,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;
 }

@@ -126,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 */
@@ -142,6 +148,10 @@ interface IDeviceVerificationUpgrade {
    crossSigningInfo: CrossSigningInfo;
 }

+export interface ICheckOwnCrossSigningTrustOpts {
+    allowPrivateKeyRequests?: boolean;
+}
+
 /**
 * @typedef {Object} module:crypto~OlmSessionResult
 * @property {module:crypto/deviceinfo} device  device info
@@ -184,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();
    }

@@ -197,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;
@@ -283,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,
@@ -496,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"]> = {};
@@ -1089,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);
        }
@@ -1105,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',
@@ -1403,9 +1413,7 @@ export class Crypto extends EventEmitter {
                crossSigning.updateCrossSigningVerifiedBefore(
                    this.checkUserTrust(userId).isCrossSigningVerified(),
                );
-                this.deviceList.setRawStoredCrossSigningForUser(
-                    userId, crossSigning.toStorage(),
-                );
+                this.deviceList.setRawStoredCrossSigningForUser(userId, crossSigning.toStorage());
            }

            this.emit("userTrustStatusChanged", userId, this.checkUserTrust(userId));
@@ -1418,7 +1426,7 @@ export class Crypto extends EventEmitter {
     */
    async checkOwnCrossSigningTrust({
        allowPrivateKeyRequests = false,
-    } = {}) {
+    }: ICheckOwnCrossSigningTrustOpts = {}): Promise<void> {
        const userId = this.userId;

        // Before proceeding, ensure our cross-signing public keys have been
@@ -1772,7 +1780,7 @@ export class Crypto extends EventEmitter {

        return this.signObject(deviceKeys).then(() => {
            return this.baseApis.uploadKeysRequest({
-                device_keys: deviceKeys,
+                device_keys: deviceKeys as Required<IDeviceKeys>,
            });
        });
    }
@@ -1904,7 +1912,7 @@ export class Crypto extends EventEmitter {
    private async uploadOneTimeKeys() {
        const promises = [];

-        const fallbackJson = {};
+        const fallbackJson: Record<string, IOneTimeKey> = {};
        if (this.getNeedsNewFallback()) {
            const fallbackKeys = await this.olmDevice.getFallbackKey();
            for (const [keyId, key] of Object.entries(fallbackKeys.curve25519)) {
@@ -2170,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);
@@ -2187,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));
        }
@@ -2205,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) {
@@ -2252,15 +2260,12 @@ export class Crypto extends EventEmitter {
    public async legacyDeviceVerification(
        userId: string,
        deviceId: string,
-        method: string,
-    ): VerificationRequest {
+        method: VerificationMethod,
+    ): 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
@@ -2465,7 +2470,7 @@ export class Crypto extends EventEmitter {
     */
    public async setRoomEncryption(
        roomId: string,
-        config: any, // TODO types
+        config: IRoomEncryption,
        inhibitDeviceQuery?: boolean,
    ): Promise<void> {
        // ignore crypto events with no algorithm defined
@@ -2522,8 +2527,8 @@ export class Crypto extends EventEmitter {
            crypto: this,
            olmDevice: this.olmDevice,
            baseApis: this.baseApis,
-            roomId: roomId,
-            config: config,
+            roomId,
+            config,
        });
        this.roomEncryptors[roomId] = alg;

@@ -2751,12 +2756,22 @@ export class Crypto extends EventEmitter {
            delete content['m.relates_to'];
        }

+        // Treat element's performance metrics the same as `m.relates_to` (when present)
+        const elementPerfMetrics = content['io.element.performance_metrics'];
+        if (elementPerfMetrics) {
+            content = Object.assign({}, content);
+            delete content['io.element.performance_metrics'];
+        }
+
        const encryptedContent = await alg.encryptMessage(
            room, event.getType(), content);

        if (mRelatesTo) {
            encryptedContent['m.relates_to'] = mRelatesTo;
        }
+        if (elementPerfMetrics) {
+            encryptedContent['io.element.performance_metrics'] = elementPerfMetrics;
+        }

        event.makeEncrypted(
            "m.room.encrypted",
@@ -2878,7 +2893,7 @@ export class Crypto extends EventEmitter {
     */
    public async onCryptoEvent(event: MatrixEvent): Promise<void> {
        const roomId = event.getRoomId();
-        const content = event.getContent();
+        const content = event.getContent<IRoomEncryption>();

        try {
            // inhibit the device list refresh for now - it will happen once we've
@@ -24,6 +24,7 @@ export interface IKeyBackupSession {
        ciphertext: string;
        ephemeral: string;
        mac: string;
+        iv: string;
    };
 }

@@ -24,11 +24,11 @@ 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";
-import { OneTimeKey } from "./dehydration";
+import { IOneTimeKey } from "./dehydration";
 import { MatrixClient } from "../client";

 enum Algorithm {
@@ -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
@@ -407,7 +405,7 @@ export async function ensureOlmSessionsForDevices(

 async function _verifyKeyAndStartSession(
    olmDevice: OlmDevice,
-    oneTimeKey: OneTimeKey,
+    oneTimeKey: IOneTimeKey,
    userId: string,
    deviceInfo: DeviceInfo,
 ): Promise<string> {
@@ -465,7 +463,7 @@ export interface IObject {
 */
 export async function verifySignature(
    olmDevice: OlmDevice,
-    obj: OneTimeKey | IObject,
+    obj: IOneTimeKey | IObject,
    signingUserId: string,
    signingDeviceId: string,
    signingKey: string,
@@ -1,5 +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 { IRoomKeyRequestBody, IRoomKeyRequestRecipient } from "../index";
+import { RoomKeyRequestState } from "../OutgoingRoomKeyRequestManager";
+import { ICrossSigningKey } from "../../client";
+import { IOlmDevice } from "../algorithms/megolm";
+import { TrackingStatus } from "../DeviceList";
+import { IRoomEncryption } from "../RoomList";
+import { IDevice } from "../deviceinfo";
+import { ICrossSigningInfo } from "../CrossSigning";
+import { PrefixedLogger } from "../../logger";
+import { InboundGroupSessionData } from "../OlmDevice";
+import { IEncryptedPayload } from "../aes";
+
 /**
- * Internal module. Defintions for storage for the crypto module
+ * Internal module. Definitions for storage for the crypto module
 *
 * @module
 */
@@ -9,9 +37,141 @@
 *
 * @interface CryptoStore
 */
+export interface CryptoStore {
+    startup(): Promise<CryptoStore>;
+    deleteAllData(): Promise<void>;
+    getOrAddOutgoingRoomKeyRequest(request: OutgoingRoomKeyRequest): Promise<OutgoingRoomKeyRequest>;
+    getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<OutgoingRoomKeyRequest | null>;
+    getOutgoingRoomKeyRequestByState(wantedStates: number[]): Promise<OutgoingRoomKeyRequest | null>;
+    getAllOutgoingRoomKeyRequestsByState(wantedState: number): Promise<OutgoingRoomKeyRequest[]>;
+    getOutgoingRoomKeyRequestsByTarget(
+        userId: string,
+        deviceId: string,
+        wantedStates: number[],
+    ): Promise<OutgoingRoomKeyRequest[]>;
+    updateOutgoingRoomKeyRequest(
+        requestId: string,
+        expectedState: number,
+        updates: Partial<OutgoingRoomKeyRequest>,
+    ): Promise<OutgoingRoomKeyRequest | null>;
+    deleteOutgoingRoomKeyRequest(requestId: string, expectedState: number): Promise<OutgoingRoomKeyRequest | null>;

-import { IRoomKeyRequestBody, IRoomKeyRequestRecipient } from "../index";
-import { RoomKeyRequestState } from "../OutgoingRoomKeyRequestManager";
+    // Olm Account
+    getAccount(txn: unknown, func: (accountPickle: string) => void);
+    storeAccount(txn: unknown, accountPickle: string): void;
+    getCrossSigningKeys(txn: unknown, func: (keys: Record<string, ICrossSigningKey>) => void): void;
+    getSecretStorePrivateKey(txn: unknown, func: (key: IEncryptedPayload | null) => void, type: string): void;
+    storeCrossSigningKeys(txn: unknown, keys: Record<string, ICrossSigningKey>): void;
+    storeSecretStorePrivateKey(txn: unknown, type: string, key: IEncryptedPayload): void;
+
+    // Olm Sessions
+    countEndToEndSessions(txn: unknown, func: (count: number) => void): void;
+    getEndToEndSession(
+        deviceKey: string,
+        sessionId: string,
+        txn: unknown,
+        func: (session: ISessionInfo) => void,
+    ): void;
+    getEndToEndSessions(
+        deviceKey: string,
+        txn: unknown,
+        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,
+    ): void;
+    getAllEndToEndSessions(txn: unknown, func: (session: ISessionInfo) => void): void;
+    storeEndToEndSession(deviceKey: string, sessionId: string, sessionInfo: ISessionInfo, txn: unknown): void;
+    storeEndToEndSessionProblem(deviceKey: string, type: string, fixed: boolean): Promise<void>;
+    getEndToEndSessionProblem(deviceKey: string, timestamp: number): Promise<IProblem | null>;
+    filterOutNotifiedErrorDevices(devices: IOlmDevice[]): Promise<IOlmDevice[]>;
+
+    // Inbound Group Sessions
+    getEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        txn: unknown,
+        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,
+    ): void;
+    getAllEndToEndInboundGroupSessions(
+        txn: unknown,
+        func: (session: ISession | null) => void,
+    ): void;
+    addEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: unknown,
+    ): void;
+    storeEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: unknown,
+    ): void;
+    storeEndToEndInboundGroupSessionWithheld(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: IWithheld,
+        txn: unknown,
+    ): void;
+
+    // Device Data
+    getEndToEndDeviceData(txn: unknown, func: (deviceData: IDeviceData | null) => void): void;
+    storeEndToEndDeviceData(deviceData: IDeviceData, txn: unknown): void;
+    storeEndToEndRoom(roomId: string, roomInfo: IRoomEncryption, txn: unknown): void;
+    getEndToEndRooms(txn: unknown, func: (rooms: Record<string, IRoomEncryption>) => void): void;
+    getSessionsNeedingBackup(limit: number): Promise<ISession[]>;
+    countSessionsNeedingBackup(txn?: unknown): Promise<number>;
+    unmarkSessionsNeedingBackup(sessions: ISession[], txn?: unknown): Promise<void>;
+    markSessionsNeedingBackup(sessions: ISession[], txn?: unknown): Promise<void>;
+    addSharedHistoryInboundGroupSession(roomId: string, senderKey: string, sessionId: string, txn?: unknown): void;
+    getSharedHistoryInboundGroupSessions(
+        roomId: string,
+        txn?: unknown,
+    ): Promise<[senderKey: string, sessionId: string][]>;
+
+    // Session key backups
+    doTxn<T>(mode: Mode, stores: Iterable<string>, func: (txn: unknown) => T, log?: PrefixedLogger): Promise<T>;
+}
+
+export type Mode = "readonly" | "readwrite";
+
+export interface ISession {
+    senderKey: string;
+    sessionId: string;
+    sessionData?: InboundGroupSessionData;
+}
+
+export interface ISessionInfo {
+    deviceKey?: string;
+    sessionId?: string;
+    session?: string;
+    lastReceivedMessageTs?: number;
+}
+
+export interface IDeviceData {
+    devices: {
+        [ userId: string ]: {
+            [ deviceId: string ]: IDevice;
+        };
+    };
+    trackingStatus: {
+        [ userId: string ]: TrackingStatus;
+    };
+    crossSigningInfo?: Record<string, ICrossSigningInfo>;
+    syncToken?: string;
+}
+
+export interface IProblem {
+    type: string;
+    fixed: boolean;
+    time: number;
+}
+
+export interface IWithheld {
+    // eslint-disable-next-line camelcase
+    room_id: string;
+    code: string;
+    reason: string;
+}

 /**
 * Represents an outgoing room key request
@@ -1,7 +1,5 @@
 /*
-Copyright 2017 Vector Creations Ltd
-Copyright 2018 New Vector Ltd
-Copyright 2020 The Matrix.org Foundation C.I.C.
+Copyright 2017 - 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.
@@ -16,8 +14,24 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { logger } from '../../logger';
+import { logger, PrefixedLogger } from '../../logger';
 import * as utils from "../../utils";
+import {
+    CryptoStore,
+    IDeviceData,
+    IProblem,
+    ISession,
+    ISessionInfo,
+    IWithheld,
+    Mode,
+    OutgoingRoomKeyRequest,
+} from "./base";
+import { IRoomKeyRequestBody } from "../index";
+import { ICrossSigningKey } from "../../client";
+import { IOlmDevice } from "../algorithms/megolm";
+import { IRoomEncryption } from "../RoomList";
+import { InboundGroupSessionData } from "../OlmDevice";
+import { IEncryptedPayload } from "../aes";

 export const VERSION = 10;
 const PROFILE_TRANSACTIONS = false;
@@ -29,23 +43,31 @@ const PROFILE_TRANSACTIONS = false;
 *
 * @implements {module:crypto/store/base~CryptoStore}
 */
-export class Backend {
+export class Backend implements CryptoStore {
+    private nextTxnId = 0;
+
    /**
     * @param {IDBDatabase} db
     */
-    constructor(db) {
-        this._db = db;
-        this._nextTxnId = 0;
-
+    constructor(private db: IDBDatabase) {
        // make sure we close the db on `onversionchange` - otherwise
        // attempts to delete the database will block (and subsequent
        // attempts to re-create it will also block).
-        db.onversionchange = (ev) => {
-            logger.log(`versionchange for indexeddb ${this._dbName}: closing`);
+        db.onversionchange = () => {
+            logger.log(`versionchange for indexeddb ${this.db.name}: closing`);
            db.close();
        };
    }

+    public async startup(): Promise<CryptoStore> {
+        // No work to do, as the startup is done by the caller (e.g IndexedDBCryptoStore)
+        // by passing us a ready IDBDatabase instance
+        return this;
+    }
+    public async deleteAllData(): Promise<void> {
+        throw Error("This is not implemented, call IDBFactory::deleteDatabase(dbName) instead.");
+    }
+
    /**
     * Look for an existing outgoing room key request, and if none is found,
     * add a new one
@@ -56,11 +78,11 @@ export class Backend {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}: either the
     *    same instance as passed in, or the existing one.
     */
-    getOrAddOutgoingRoomKeyRequest(request) {
+    public getOrAddOutgoingRoomKeyRequest(request: OutgoingRoomKeyRequest): Promise<OutgoingRoomKeyRequest> {
        const requestBody = request.requestBody;

        return new Promise((resolve, reject) => {
-            const txn = this._db.transaction("outgoingRoomKeyRequests", "readwrite");
+            const txn = this.db.transaction("outgoingRoomKeyRequests", "readwrite");
            txn.onerror = reject;

            // first see if we already have an entry for this request.
@@ -99,9 +121,9 @@ export class Backend {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
     *    not found
     */
-    getOutgoingRoomKeyRequest(requestBody) {
+    public getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<OutgoingRoomKeyRequest | null> {
        return new Promise((resolve, reject) => {
-            const txn = this._db.transaction("outgoingRoomKeyRequests", "readonly");
+            const txn = this.db.transaction("outgoingRoomKeyRequests", "readonly");
            txn.onerror = reject;

            this._getOutgoingRoomKeyRequest(txn, requestBody, (existing) => {
@@ -122,7 +144,12 @@ export class Backend {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
     *    not found.
     */
-    _getOutgoingRoomKeyRequest(txn, requestBody, callback) {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    private _getOutgoingRoomKeyRequest(
+        txn: IDBTransaction,
+        requestBody: IRoomKeyRequestBody,
+        callback: (req: OutgoingRoomKeyRequest | null) => void,
+    ): void {
        const store = txn.objectStore("outgoingRoomKeyRequests");

        const idx = store.index("session");
@@ -131,8 +158,8 @@ export class Backend {
            requestBody.session_id,
        ]);

-        cursorReq.onsuccess = (ev) => {
-            const cursor = ev.target.result;
+        cursorReq.onsuccess = () => {
+            const cursor = cursorReq.result;
            if (!cursor) {
                // no match found
                callback(null);
@@ -162,7 +189,7 @@ export class Backend {
     *    there are no pending requests in those states. If there are multiple
     *    requests in those states, an arbitrary one is chosen.
     */
-    getOutgoingRoomKeyRequestByState(wantedStates) {
+    public getOutgoingRoomKeyRequestByState(wantedStates: number[]): Promise<OutgoingRoomKeyRequest | null> {
        if (wantedStates.length === 0) {
            return Promise.resolve(null);
        }
@@ -195,7 +222,7 @@ export class Backend {
            cursorReq.onsuccess = onsuccess;
        }

-        const txn = this._db.transaction("outgoingRoomKeyRequests", "readonly");
+        const txn = this.db.transaction("outgoingRoomKeyRequests", "readonly");
        const store = txn.objectStore("outgoingRoomKeyRequests");

        const wantedState = wantedStates[stateIndex];
@@ -210,19 +237,23 @@ export class Backend {
     * @param {Number} wantedState
     * @return {Promise<Array<*>>} All elements in a given state
     */
-    getAllOutgoingRoomKeyRequestsByState(wantedState) {
+    public getAllOutgoingRoomKeyRequestsByState(wantedState: number): Promise<OutgoingRoomKeyRequest[]> {
        return new Promise((resolve, reject) => {
-            const txn = this._db.transaction("outgoingRoomKeyRequests", "readonly");
+            const txn = this.db.transaction("outgoingRoomKeyRequests", "readonly");
            const store = txn.objectStore("outgoingRoomKeyRequests");
            const index = store.index("state");
            const request = index.getAll(wantedState);

-            request.onsuccess = (ev) => resolve(ev.target.result);
-            request.onerror = (ev) => reject(ev.target.error);
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
        });
    }

-    getOutgoingRoomKeyRequestsByTarget(userId, deviceId, wantedStates) {
+    public getOutgoingRoomKeyRequestsByTarget(
+        userId: string,
+        deviceId: string,
+        wantedStates: number[],
+    ): Promise<OutgoingRoomKeyRequest[]> {
        let stateIndex = 0;
        const results = [];

@@ -248,7 +279,7 @@ export class Backend {
            }
        }

-        const txn = this._db.transaction("outgoingRoomKeyRequests", "readonly");
+        const txn = this.db.transaction("outgoingRoomKeyRequests", "readonly");
        const store = txn.objectStore("outgoingRoomKeyRequests");

        const wantedState = wantedStates[stateIndex];
@@ -270,7 +301,11 @@ export class Backend {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
     *    updated request, or null if no matching row was found
     */
-    updateOutgoingRoomKeyRequest(requestId, expectedState, updates) {
+    public updateOutgoingRoomKeyRequest(
+        requestId: string,
+        expectedState: number,
+        updates: Partial<OutgoingRoomKeyRequest>,
+    ): Promise<OutgoingRoomKeyRequest | null> {
        let result = null;

        function onsuccess(ev) {
@@ -291,9 +326,8 @@ export class Backend {
            result = data;
        }

-        const txn = this._db.transaction("outgoingRoomKeyRequests", "readwrite");
-        const cursorReq = txn.objectStore("outgoingRoomKeyRequests")
-                  .openCursor(requestId);
+        const txn = this.db.transaction("outgoingRoomKeyRequests", "readwrite");
+        const cursorReq = txn.objectStore("outgoingRoomKeyRequests").openCursor(requestId);
        cursorReq.onsuccess = onsuccess;
        return promiseifyTxn(txn).then(() => result);
    }
@@ -307,12 +341,14 @@ export class Backend {
     *
     * @returns {Promise} resolves once the operation is completed
     */
-    deleteOutgoingRoomKeyRequest(requestId, expectedState) {
-        const txn = this._db.transaction("outgoingRoomKeyRequests", "readwrite");
-        const cursorReq = txn.objectStore("outgoingRoomKeyRequests")
-                  .openCursor(requestId);
-        cursorReq.onsuccess = (ev) => {
-            const cursor = ev.target.result;
+    public deleteOutgoingRoomKeyRequest(
+        requestId: string,
+        expectedState: number,
+    ): Promise<OutgoingRoomKeyRequest | null> {
+        const txn = this.db.transaction("outgoingRoomKeyRequests", "readwrite");
+        const cursorReq = txn.objectStore("outgoingRoomKeyRequests").openCursor(requestId);
+        cursorReq.onsuccess = () => {
+            const cursor = cursorReq.result;
            if (!cursor) {
                return;
            }
@@ -326,12 +362,12 @@ export class Backend {
            }
            cursor.delete();
        };
-        return promiseifyTxn(txn);
+        return promiseifyTxn<OutgoingRoomKeyRequest | null>(txn);
    }

    // Olm Account

-    getAccount(txn, func) {
+    public getAccount(txn: IDBTransaction, func: (accountPickle: string) => void): void {
        const objectStore = txn.objectStore("account");
        const getReq = objectStore.get("-");
        getReq.onsuccess = function() {
@@ -343,12 +379,12 @@ export class Backend {
        };
    }

-    storeAccount(txn, newData) {
+    public storeAccount(txn: IDBTransaction, accountPickle: string): void {
        const objectStore = txn.objectStore("account");
-        objectStore.put(newData, "-");
+        objectStore.put(accountPickle, "-");
    }

-    getCrossSigningKeys(txn, func) {
+    public getCrossSigningKeys(txn: IDBTransaction, func: (keys: Record<string, ICrossSigningKey>) => void): void {
        const objectStore = txn.objectStore("account");
        const getReq = objectStore.get("crossSigningKeys");
        getReq.onsuccess = function() {
@@ -360,7 +396,11 @@ export class Backend {
        };
    }

-    getSecretStorePrivateKey(txn, func, type) {
+    public getSecretStorePrivateKey(
+        txn: IDBTransaction,
+        func: (key: IEncryptedPayload | null) => void,
+        type: string,
+    ): void {
        const objectStore = txn.objectStore("account");
        const getReq = objectStore.get(`ssss_cache:${type}`);
        getReq.onsuccess = function() {
@@ -372,19 +412,19 @@ export class Backend {
        };
    }

-    storeCrossSigningKeys(txn, keys) {
+    public storeCrossSigningKeys(txn: IDBTransaction, keys: Record<string, ICrossSigningKey>): void {
        const objectStore = txn.objectStore("account");
        objectStore.put(keys, "crossSigningKeys");
    }

-    storeSecretStorePrivateKey(txn, type, key) {
+    public storeSecretStorePrivateKey(txn: IDBTransaction, type: string, key: IEncryptedPayload): void {
        const objectStore = txn.objectStore("account");
        objectStore.put(key, `ssss_cache:${type}`);
    }

    // Olm Sessions

-    countEndToEndSessions(txn, func) {
+    public countEndToEndSessions(txn: IDBTransaction, func: (count: number) => void): void {
        const objectStore = txn.objectStore("sessions");
        const countReq = objectStore.count();
        countReq.onsuccess = function() {
@@ -396,7 +436,11 @@ export class Backend {
        };
    }

-    getEndToEndSessions(deviceKey, txn, func) {
+    public getEndToEndSessions(
+        deviceKey: string,
+        txn: IDBTransaction,
+        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,
+    ): void {
        const objectStore = txn.objectStore("sessions");
        const idx = objectStore.index("deviceKey");
        const getReq = idx.openCursor(deviceKey);
@@ -419,7 +463,12 @@ export class Backend {
        };
    }

-    getEndToEndSession(deviceKey, sessionId, txn, func) {
+    public getEndToEndSession(
+        deviceKey: string,
+        sessionId: string,
+        txn: IDBTransaction,
+        func: (sessions: { [ sessionId: string ]: ISessionInfo }) => void,
+    ): void {
        const objectStore = txn.objectStore("sessions");
        const getReq = objectStore.get([deviceKey, sessionId]);
        getReq.onsuccess = function() {
@@ -438,7 +487,7 @@ export class Backend {
        };
    }

-    getAllEndToEndSessions(txn, func) {
+    public getAllEndToEndSessions(txn: IDBTransaction, func: (session: ISessionInfo) => void): void {
        const objectStore = txn.objectStore("sessions");
        const getReq = objectStore.openCursor();
        getReq.onsuccess = function() {
@@ -456,7 +505,12 @@ export class Backend {
        };
    }

-    storeEndToEndSession(deviceKey, sessionId, sessionInfo, txn) {
+    public storeEndToEndSession(
+        deviceKey: string,
+        sessionId: string,
+        sessionInfo: ISessionInfo,
+        txn: IDBTransaction,
+    ): void {
        const objectStore = txn.objectStore("sessions");
        objectStore.put({
            deviceKey,
@@ -466,8 +520,8 @@ export class Backend {
        });
    }

-    async storeEndToEndSessionProblem(deviceKey, type, fixed) {
-        const txn = this._db.transaction("session_problems", "readwrite");
+    public async storeEndToEndSessionProblem(deviceKey: string, type: string, fixed: boolean): Promise<void> {
+        const txn = this.db.transaction("session_problems", "readwrite");
        const objectStore = txn.objectStore("session_problems");
        objectStore.put({
            deviceKey,
@@ -478,13 +532,13 @@ export class Backend {
        return promiseifyTxn(txn);
    }

-    async getEndToEndSessionProblem(deviceKey, timestamp) {
+    public async getEndToEndSessionProblem(deviceKey: string, timestamp: number): Promise<IProblem | null> {
        let result;
-        const txn = this._db.transaction("session_problems", "readwrite");
+        const txn = this.db.transaction("session_problems", "readwrite");
        const objectStore = txn.objectStore("session_problems");
        const index = objectStore.index("deviceKey");
        const req = index.getAll(deviceKey);
-        req.onsuccess = (event) => {
+        req.onsuccess = () => {
            const problems = req.result;
            if (!problems.length) {
                result = null;
@@ -511,14 +565,14 @@ export class Backend {
    }

    // FIXME: we should probably prune this when devices get deleted
-    async filterOutNotifiedErrorDevices(devices) {
-        const txn = this._db.transaction("notified_error_devices", "readwrite");
+    public async filterOutNotifiedErrorDevices(devices: IOlmDevice[]): Promise<IOlmDevice[]> {
+        const txn = this.db.transaction("notified_error_devices", "readwrite");
        const objectStore = txn.objectStore("notified_error_devices");

-        const ret = [];
+        const ret: IOlmDevice[] = [];

        await Promise.all(devices.map((device) => {
-            return new Promise((resolve) => {
+            return new Promise<void>((resolve) => {
                const { userId, deviceInfo } = device;
                const getReq = objectStore.get([userId, deviceInfo.deviceId]);
                getReq.onsuccess = function() {
@@ -536,9 +590,14 @@ export class Backend {

    // Inbound group sessions

-    getEndToEndInboundGroupSession(senderCurve25519Key, sessionId, txn, func) {
-        let session = false;
-        let withheld = false;
+    public getEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        txn: IDBTransaction,
+        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,
+    ): void {
+        let session: InboundGroupSessionData | boolean = false;
+        let withheld: IWithheld | boolean = false;
        const objectStore = txn.objectStore("inbound_group_sessions");
        const getReq = objectStore.get([senderCurve25519Key, sessionId]);
        getReq.onsuccess = function() {
@@ -549,7 +608,7 @@ export class Backend {
                    session = null;
                }
                if (withheld !== false) {
-                    func(session, withheld);
+                    func(session as InboundGroupSessionData, withheld as IWithheld);
                }
            } catch (e) {
                abortWithException(txn, e);
@@ -566,7 +625,7 @@ export class Backend {
                    withheld = null;
                }
                if (session !== false) {
-                    func(session, withheld);
+                    func(session as InboundGroupSessionData, withheld as IWithheld);
                }
            } catch (e) {
                abortWithException(txn, e);
@@ -574,7 +633,7 @@ export class Backend {
        };
    }

-    getAllEndToEndInboundGroupSessions(txn, func) {
+    public getAllEndToEndInboundGroupSessions(txn: IDBTransaction, func: (session: ISession | null) => void): void {
        const objectStore = txn.objectStore("inbound_group_sessions");
        const getReq = objectStore.openCursor();
        getReq.onsuccess = function() {
@@ -600,7 +659,12 @@ export class Backend {
        };
    }

-    addEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn) {
+    public addEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: IDBTransaction,
+    ): void {
        const objectStore = txn.objectStore("inbound_group_sessions");
        const addReq = objectStore.add({
            senderCurve25519Key, sessionId, session: sessionData,
@@ -623,23 +687,31 @@ export class Backend {
        };
    }

-    storeEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn) {
+    public storeEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: IDBTransaction,
+    ): void {
        const objectStore = txn.objectStore("inbound_group_sessions");
        objectStore.put({
            senderCurve25519Key, sessionId, session: sessionData,
        });
    }

-    storeEndToEndInboundGroupSessionWithheld(
-        senderCurve25519Key, sessionId, sessionData, txn,
-    ) {
+    public storeEndToEndInboundGroupSessionWithheld(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: IWithheld,
+        txn: IDBTransaction,
+    ): void {
        const objectStore = txn.objectStore("inbound_group_sessions_withheld");
        objectStore.put({
            senderCurve25519Key, sessionId, session: sessionData,
        });
    }

-    getEndToEndDeviceData(txn, func) {
+    public getEndToEndDeviceData(txn: IDBTransaction, func: (deviceData: IDeviceData | null) => void): void {
        const objectStore = txn.objectStore("device_data");
        const getReq = objectStore.get("-");
        getReq.onsuccess = function() {
@@ -651,24 +723,24 @@ export class Backend {
        };
    }

-    storeEndToEndDeviceData(deviceData, txn) {
+    public storeEndToEndDeviceData(deviceData: IDeviceData, txn: IDBTransaction): void {
        const objectStore = txn.objectStore("device_data");
        objectStore.put(deviceData, "-");
    }

-    storeEndToEndRoom(roomId, roomInfo, txn) {
+    public storeEndToEndRoom(roomId: string, roomInfo: IRoomEncryption, txn: IDBTransaction): void {
        const objectStore = txn.objectStore("rooms");
        objectStore.put(roomInfo, roomId);
    }

-    getEndToEndRooms(txn, func) {
+    public getEndToEndRooms(txn: IDBTransaction, func: (rooms: Record<string, IRoomEncryption>) => void): void {
        const rooms = {};
        const objectStore = txn.objectStore("rooms");
        const getReq = objectStore.openCursor();
        getReq.onsuccess = function() {
            const cursor = getReq.result;
            if (cursor) {
-                rooms[cursor.key] = cursor.value;
+                rooms[cursor.key as string] = cursor.value;
                cursor.continue();
            } else {
                try {
@@ -682,11 +754,11 @@ export class Backend {

    // session backups

-    getSessionsNeedingBackup(limit) {
+    public getSessionsNeedingBackup(limit: number): Promise<ISession[]> {
        return new Promise((resolve, reject) => {
            const sessions = [];

-            const txn = this._db.transaction(
+            const txn = this.db.transaction(
                ["sessions_needing_backup", "inbound_group_sessions"],
                "readonly",
            );
@@ -716,9 +788,9 @@ export class Backend {
        });
    }

-    countSessionsNeedingBackup(txn) {
+    public countSessionsNeedingBackup(txn?: IDBTransaction): Promise<number> {
        if (!txn) {
-            txn = this._db.transaction("sessions_needing_backup", "readonly");
+            txn = this.db.transaction("sessions_needing_backup", "readonly");
        }
        const objectStore = txn.objectStore("sessions_needing_backup");
        return new Promise((resolve, reject) => {
@@ -728,12 +800,12 @@ export class Backend {
        });
    }

-    unmarkSessionsNeedingBackup(sessions, txn) {
+    public async unmarkSessionsNeedingBackup(sessions: ISession[], txn?: IDBTransaction): Promise<void> {
        if (!txn) {
-            txn = this._db.transaction("sessions_needing_backup", "readwrite");
+            txn = this.db.transaction("sessions_needing_backup", "readwrite");
        }
        const objectStore = txn.objectStore("sessions_needing_backup");
-        return Promise.all(sessions.map((session) => {
+        await Promise.all(sessions.map((session) => {
            return new Promise((resolve, reject) => {
                const req = objectStore.delete([session.senderKey, session.sessionId]);
                req.onsuccess = resolve;
@@ -742,12 +814,12 @@ export class Backend {
        }));
    }

-    markSessionsNeedingBackup(sessions, txn) {
+    public async markSessionsNeedingBackup(sessions: ISession[], txn?: IDBTransaction): Promise<void> {
        if (!txn) {
-            txn = this._db.transaction("sessions_needing_backup", "readwrite");
+            txn = this.db.transaction("sessions_needing_backup", "readwrite");
        }
        const objectStore = txn.objectStore("sessions_needing_backup");
-        return Promise.all(sessions.map((session) => {
+        await Promise.all(sessions.map((session) => {
            return new Promise((resolve, reject) => {
                const req = objectStore.put({
                    senderCurve25519Key: session.senderKey,
@@ -759,9 +831,14 @@ export class Backend {
        }));
    }

-    addSharedHistoryInboundGroupSession(roomId, senderKey, sessionId, txn) {
+    public addSharedHistoryInboundGroupSession(
+        roomId: string,
+        senderKey: string,
+        sessionId: string,
+        txn?: IDBTransaction,
+    ): void {
        if (!txn) {
-            txn = this._db.transaction(
+            txn = this.db.transaction(
                "shared_history_inbound_group_sessions", "readwrite",
            );
        }
@@ -774,9 +851,12 @@ export class Backend {
        };
    }

-    getSharedHistoryInboundGroupSessions(roomId, txn) {
+    public getSharedHistoryInboundGroupSessions(
+        roomId: string,
+        txn?: IDBTransaction,
+    ): Promise<[senderKey: string, sessionId: string][]> {
        if (!txn) {
-            txn = this._db.transaction(
+            txn = this.db.transaction(
                "shared_history_inbound_group_sessions", "readonly",
            );
        }
@@ -791,16 +871,21 @@ export class Backend {
        });
    }

-    doTxn(mode, stores, func, log = logger) {
+    public doTxn<T>(
+        mode: Mode,
+        stores: Iterable<string>,
+        func: (txn: IDBTransaction) => T,
+        log: PrefixedLogger = logger,
+    ): Promise<T> {
        let startTime;
        let description;
        if (PROFILE_TRANSACTIONS) {
-            const txnId = this._nextTxnId++;
+            const txnId = this.nextTxnId++;
            startTime = Date.now();
            description = `${mode} crypto store transaction ${txnId} in ${stores}`;
            log.debug(`Starting ${description}`);
        }
-        const txn = this._db.transaction(stores, mode);
+        const txn = this.db.transaction(stores, mode);
        const promise = promiseifyTxn(txn);
        const result = func(txn);
        if (PROFILE_TRANSACTIONS) {
@@ -818,7 +903,7 @@ export class Backend {
    }
 }

-export function upgradeDatabase(db, oldVersion) {
+export function upgradeDatabase(db: IDBDatabase, oldVersion: number): void {
    logger.log(
        `Upgrading IndexedDBCryptoStore from version ${oldVersion}`
            + ` to ${VERSION}`,
@@ -874,7 +959,7 @@ export function upgradeDatabase(db, oldVersion) {
    // Expand as needed.
 }

-function createDatabase(db) {
+function createDatabase(db: IDBDatabase): void {
    const outgoingRoomKeyRequestsStore =
        db.createObjectStore("outgoingRoomKeyRequests", { keyPath: "requestId" });

@@ -887,15 +972,19 @@ function createDatabase(db) {
    outgoingRoomKeyRequestsStore.createIndex("state", "state");
 }

+interface IWrappedIDBTransaction extends IDBTransaction {
+    _mx_abortexception: Error; // eslint-disable-line camelcase
+}
+
 /*
 * Aborts a transaction with a given exception
 * The transaction promise will be rejected with this exception.
 */
-function abortWithException(txn, e) {
+function abortWithException(txn: IDBTransaction, e: Error) {
    // We cheekily stick our exception onto the transaction object here
    // We could alternatively make the thing we pass back to the app
    // an object containing the transaction and exception.
-    txn._mx_abortexception = e;
+    (txn as IWrappedIDBTransaction)._mx_abortexception = e;
    try {
        txn.abort();
    } catch (e) {
@@ -904,28 +993,28 @@ function abortWithException(txn, e) {
    }
 }

-function promiseifyTxn(txn) {
+function promiseifyTxn<T>(txn: IDBTransaction): Promise<T> {
    return new Promise((resolve, reject) => {
        txn.oncomplete = () => {
-            if (txn._mx_abortexception !== undefined) {
-                reject(txn._mx_abortexception);
+            if ((txn as IWrappedIDBTransaction)._mx_abortexception !== undefined) {
+                reject((txn as IWrappedIDBTransaction)._mx_abortexception);
            }
-            resolve();
+            resolve(null);
        };
        txn.onerror = (event) => {
-            if (txn._mx_abortexception !== undefined) {
-                reject(txn._mx_abortexception);
+            if ((txn as IWrappedIDBTransaction)._mx_abortexception !== undefined) {
+                reject((txn as IWrappedIDBTransaction)._mx_abortexception);
            } else {
                logger.log("Error performing indexeddb txn", event);
-                reject(event.target.error);
+                reject(txn.error);
            }
        };
        txn.onabort = (event) => {
-            if (txn._mx_abortexception !== undefined) {
-                reject(txn._mx_abortexception);
+            if ((txn as IWrappedIDBTransaction)._mx_abortexception !== undefined) {
+                reject((txn as IWrappedIDBTransaction)._mx_abortexception);
            } else {
                logger.log("Error performing indexeddb txn", event);
-                reject(event.target.error);
+                reject(txn.error);
            }
        };
    });
@@ -1,7 +1,5 @@
 /*
-Copyright 2017 Vector Creations Ltd
-Copyright 2018 New Vector Ltd
-Copyright 2020 The Matrix.org Foundation C.I.C.
+Copyright 2017 - 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.
@@ -16,12 +14,28 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { logger } from '../../logger';
+import { logger, PrefixedLogger } from '../../logger';
 import { LocalStorageCryptoStore } from './localStorage-crypto-store';
 import { MemoryCryptoStore } from './memory-crypto-store';
 import * as IndexedDBCryptoStoreBackend from './indexeddb-crypto-store-backend';
 import { InvalidCryptoStoreError } from '../../errors';
 import * as IndexedDBHelpers from "../../indexeddb-helpers";
+import {
+    CryptoStore,
+    IDeviceData,
+    IProblem,
+    ISession,
+    ISessionInfo,
+    IWithheld,
+    Mode,
+    OutgoingRoomKeyRequest,
+} from "./base";
+import { IRoomKeyRequestBody } from "../index";
+import { ICrossSigningKey } from "../../client";
+import { IOlmDevice } from "../algorithms/megolm";
+import { IRoomEncryption } from "../RoomList";
+import { InboundGroupSessionData } from "../OlmDevice";
+import { IEncryptedPayload } from "../aes";

 /**
 * Internal module. indexeddb storage for e2e.
@@ -35,23 +49,30 @@ import * as IndexedDBHelpers from "../../indexeddb-helpers";
 *
 * @implements {module:crypto/store/base~CryptoStore}
 */
-export class IndexedDBCryptoStore {
+export class IndexedDBCryptoStore implements CryptoStore {
+    public static STORE_ACCOUNT = 'account';
+    public static STORE_SESSIONS = 'sessions';
+    public static STORE_INBOUND_GROUP_SESSIONS = 'inbound_group_sessions';
+    public static STORE_INBOUND_GROUP_SESSIONS_WITHHELD = 'inbound_group_sessions_withheld';
+    public static STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS = 'shared_history_inbound_group_sessions';
+    public static STORE_DEVICE_DATA = 'device_data';
+    public static STORE_ROOMS = 'rooms';
+    public static STORE_BACKUP = 'sessions_needing_backup';
+
+    public static exists(indexedDB: IDBFactory, dbName: string): Promise<boolean> {
+        return IndexedDBHelpers.exists(indexedDB, dbName);
+    }
+
+    private backendPromise: Promise<CryptoStore> = null;
+    private backend: CryptoStore = null;
+
    /**
     * Create a new IndexedDBCryptoStore
     *
     * @param {IDBFactory} indexedDB  global indexedDB instance
     * @param {string} dbName   name of db to connect to
     */
-    constructor(indexedDB, dbName) {
-        this._indexedDB = indexedDB;
-        this._dbName = dbName;
-        this._backendPromise = null;
-        this._backend = null;
-    }
-
-    static exists(indexedDB, dbName) {
-        return IndexedDBHelpers.exists(indexedDB, dbName);
-    }
+    constructor(private readonly indexedDB: IDBFactory, private readonly dbName: string) {}

    /**
     * Ensure the database exists and is up-to-date, or fall back to
@@ -62,25 +83,23 @@ export class IndexedDBCryptoStore {
     * @return {Promise} resolves to either an IndexedDBCryptoStoreBackend.Backend,
     * or a MemoryCryptoStore
     */
-    startup() {
-        if (this._backendPromise) {
-            return this._backendPromise;
+    public startup(): Promise<CryptoStore> {
+        if (this.backendPromise) {
+            return this.backendPromise;
        }

-        this._backendPromise = new Promise((resolve, reject) => {
-            if (!this._indexedDB) {
+        this.backendPromise = new Promise<CryptoStore>((resolve, reject) => {
+            if (!this.indexedDB) {
                reject(new Error('no indexeddb support available'));
                return;
            }

-            logger.log(`connecting to indexeddb ${this._dbName}`);
+            logger.log(`connecting to indexeddb ${this.dbName}`);

-            const req = this._indexedDB.open(
-                this._dbName, IndexedDBCryptoStoreBackend.VERSION,
-            );
+            const req = this.indexedDB.open(this.dbName, IndexedDBCryptoStoreBackend.VERSION);

            req.onupgradeneeded = (ev) => {
-                const db = ev.target.result;
+                const db = req.result;
                const oldVersion = ev.oldVersion;
                IndexedDBCryptoStoreBackend.upgradeDatabase(db, oldVersion);
            };
@@ -93,13 +112,13 @@ export class IndexedDBCryptoStore {

            req.onerror = (ev) => {
                logger.log("Error connecting to indexeddb", ev);
-                reject(ev.target.error);
+                reject(req.error);
            };

-            req.onsuccess = (r) => {
-                const db = r.target.result;
+            req.onsuccess = () => {
+                const db = req.result;

-                logger.log(`connected to indexeddb ${this._dbName}`);
+                logger.log(`connected to indexeddb ${this.dbName}`);
                resolve(new IndexedDBCryptoStoreBackend.Backend(db));
            };
        }).then((backend) => {
@@ -114,9 +133,7 @@ export class IndexedDBCryptoStore {
                ],
                (txn) => {
                    backend.getEndToEndInboundGroupSession('', '', txn, () => {});
-                }).then(() => {
-                    return backend;
-                },
+                }).then(() => backend,
            );
        }).catch((e) => {
            if (e.name === 'VersionError') {
@@ -126,7 +143,7 @@ export class IndexedDBCryptoStore {
                throw new InvalidCryptoStoreError(InvalidCryptoStoreError.TOO_NEW);
            }
            logger.warn(
-                `unable to connect to indexeddb ${this._dbName}` +
+                `unable to connect to indexeddb ${this.dbName}` +
                    `: falling back to localStorage store: ${e}`,
            );

@@ -139,10 +156,11 @@ export class IndexedDBCryptoStore {
                return new MemoryCryptoStore();
            }
        }).then(backend => {
-            this._backend = backend;
+            this.backend = backend;
+            return backend as CryptoStore;
        });

-        return this._backendPromise;
+        return this.backendPromise;
    }

    /**
@@ -150,15 +168,15 @@ export class IndexedDBCryptoStore {
     *
     * @returns {Promise} resolves when the store has been cleared.
     */
-    deleteAllData() {
-        return new Promise((resolve, reject) => {
-            if (!this._indexedDB) {
+    public deleteAllData(): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            if (!this.indexedDB) {
                reject(new Error('no indexeddb support available'));
                return;
            }

-            logger.log(`Removing indexeddb instance: ${this._dbName}`);
-            const req = this._indexedDB.deleteDatabase(this._dbName);
+            logger.log(`Removing indexeddb instance: ${this.dbName}`);
+            const req = this.indexedDB.deleteDatabase(this.dbName);

            req.onblocked = () => {
                logger.log(
@@ -168,11 +186,11 @@ export class IndexedDBCryptoStore {

            req.onerror = (ev) => {
                logger.log("Error deleting data from indexeddb", ev);
-                reject(ev.target.error);
+                reject(req.error);
            };

            req.onsuccess = () => {
-                logger.log(`Removed indexeddb instance: ${this._dbName}`);
+                logger.log(`Removed indexeddb instance: ${this.dbName}`);
                resolve();
            };
        }).catch((e) => {
@@ -193,8 +211,8 @@ export class IndexedDBCryptoStore {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}: either the
     *    same instance as passed in, or the existing one.
     */
-    getOrAddOutgoingRoomKeyRequest(request) {
-        return this._backend.getOrAddOutgoingRoomKeyRequest(request);
+    public getOrAddOutgoingRoomKeyRequest(request: OutgoingRoomKeyRequest): Promise<OutgoingRoomKeyRequest> {
+        return this.backend.getOrAddOutgoingRoomKeyRequest(request);
    }

    /**
@@ -207,8 +225,8 @@ export class IndexedDBCryptoStore {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
     *    not found
     */
-    getOutgoingRoomKeyRequest(requestBody) {
-        return this._backend.getOutgoingRoomKeyRequest(requestBody);
+    public getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<OutgoingRoomKeyRequest | null> {
+        return this.backend.getOutgoingRoomKeyRequest(requestBody);
    }

    /**
@@ -221,8 +239,8 @@ export class IndexedDBCryptoStore {
     *    there are no pending requests in those states. If there are multiple
     *    requests in those states, an arbitrary one is chosen.
     */
-    getOutgoingRoomKeyRequestByState(wantedStates) {
-        return this._backend.getOutgoingRoomKeyRequestByState(wantedStates);
+    public getOutgoingRoomKeyRequestByState(wantedStates: number[]): Promise<OutgoingRoomKeyRequest | null> {
+        return this.backend.getOutgoingRoomKeyRequestByState(wantedStates);
    }

    /**
@@ -232,8 +250,8 @@ export class IndexedDBCryptoStore {
     * @param {Number} wantedState
     * @return {Promise<Array<*>>} Returns an array of requests in the given state
     */
-    getAllOutgoingRoomKeyRequestsByState(wantedState) {
-        return this._backend.getAllOutgoingRoomKeyRequestsByState(wantedState);
+    public getAllOutgoingRoomKeyRequestsByState(wantedState: number): Promise<OutgoingRoomKeyRequest[]> {
+        return this.backend.getAllOutgoingRoomKeyRequestsByState(wantedState);
    }

    /**
@@ -246,8 +264,12 @@ export class IndexedDBCryptoStore {
     * @return {Promise} resolves to a list of all the
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
     */
-    getOutgoingRoomKeyRequestsByTarget(userId, deviceId, wantedStates) {
-        return this._backend.getOutgoingRoomKeyRequestsByTarget(
+    public getOutgoingRoomKeyRequestsByTarget(
+        userId: string,
+        deviceId: string,
+        wantedStates: number[],
+    ): Promise<OutgoingRoomKeyRequest[]> {
+        return this.backend.getOutgoingRoomKeyRequestsByTarget(
            userId, deviceId, wantedStates,
        );
    }
@@ -264,8 +286,12 @@ export class IndexedDBCryptoStore {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
     *    updated request, or null if no matching row was found
     */
-    updateOutgoingRoomKeyRequest(requestId, expectedState, updates) {
-        return this._backend.updateOutgoingRoomKeyRequest(
+    public updateOutgoingRoomKeyRequest(
+        requestId: string,
+        expectedState: number,
+        updates: Partial<OutgoingRoomKeyRequest>,
+    ): Promise<OutgoingRoomKeyRequest | null> {
+        return this.backend.updateOutgoingRoomKeyRequest(
            requestId, expectedState, updates,
        );
    }
@@ -279,8 +305,11 @@ export class IndexedDBCryptoStore {
     *
     * @returns {Promise} resolves once the operation is completed
     */
-    deleteOutgoingRoomKeyRequest(requestId, expectedState) {
-        return this._backend.deleteOutgoingRoomKeyRequest(requestId, expectedState);
+    public deleteOutgoingRoomKeyRequest(
+        requestId: string,
+        expectedState: number,
+    ): Promise<OutgoingRoomKeyRequest | null> {
+        return this.backend.deleteOutgoingRoomKeyRequest(requestId, expectedState);
    }

    // Olm Account
@@ -292,8 +321,8 @@ export class IndexedDBCryptoStore {
     * @param {*} txn An active transaction. See doTxn().
     * @param {function(string)} func Called with the account pickle
     */
-    getAccount(txn, func) {
-        this._backend.getAccount(txn, func);
+    public getAccount(txn: IDBTransaction, func: (accountPickle: string) => void) {
+        this.backend.getAccount(txn, func);
    }

    /**
@@ -301,10 +330,10 @@ export class IndexedDBCryptoStore {
     * This requires an active transaction. See doTxn().
     *
     * @param {*} txn An active transaction. See doTxn().
-     * @param {string} newData The new account pickle to store.
+     * @param {string} accountPickle The new account pickle to store.
     */
-    storeAccount(txn, newData) {
-        this._backend.storeAccount(txn, newData);
+    public storeAccount(txn: IDBTransaction, accountPickle: string): void {
+        this.backend.storeAccount(txn, accountPickle);
    }

    /**
@@ -315,8 +344,8 @@ export class IndexedDBCryptoStore {
     * @param {function(string)} func Called with the account keys object:
     *        { key_type: base64 encoded seed } where key type = user_signing_key_seed or self_signing_key_seed
     */
-    getCrossSigningKeys(txn, func) {
-        this._backend.getCrossSigningKeys(txn, func);
+    public getCrossSigningKeys(txn: IDBTransaction, func: (keys: Record<string, ICrossSigningKey>) => void): void {
+        this.backend.getCrossSigningKeys(txn, func);
    }

    /**
@@ -324,8 +353,12 @@ export class IndexedDBCryptoStore {
     * @param {function(string)} func Called with the private key
     * @param {string} type A key type
     */
-    getSecretStorePrivateKey(txn, func, type) {
-        this._backend.getSecretStorePrivateKey(txn, func, type);
+    public getSecretStorePrivateKey(
+        txn: IDBTransaction,
+        func: (key: IEncryptedPayload | null) => void,
+        type: string,
+    ): void {
+        this.backend.getSecretStorePrivateKey(txn, func, type);
    }

    /**
@@ -334,8 +367,8 @@ export class IndexedDBCryptoStore {
     * @param {*} txn An active transaction. See doTxn().
     * @param {string} keys keys object as getCrossSigningKeys()
     */
-    storeCrossSigningKeys(txn, keys) {
-        this._backend.storeCrossSigningKeys(txn, keys);
+    public storeCrossSigningKeys(txn: IDBTransaction, keys: Record<string, ICrossSigningKey>): void {
+        this.backend.storeCrossSigningKeys(txn, keys);
    }

    /**
@@ -345,8 +378,8 @@ export class IndexedDBCryptoStore {
     * @param {string} type The type of cross-signing private key to store
     * @param {string} key keys object as getCrossSigningKeys()
     */
-    storeSecretStorePrivateKey(txn, type, key) {
-        this._backend.storeSecretStorePrivateKey(txn, type, key);
+    public storeSecretStorePrivateKey(txn: IDBTransaction, type: string, key: IEncryptedPayload): void {
+        this.backend.storeSecretStorePrivateKey(txn, type, key);
    }

    // Olm sessions
@@ -356,8 +389,8 @@ export class IndexedDBCryptoStore {
     * @param {*} txn An active transaction. See doTxn().
     * @param {function(int)} func Called with the count of sessions
     */
-    countEndToEndSessions(txn, func) {
-        this._backend.countEndToEndSessions(txn, func);
+    public countEndToEndSessions(txn: IDBTransaction, func: (count: number) => void): void {
+        this.backend.countEndToEndSessions(txn, func);
    }

    /**
@@ -372,8 +405,13 @@ export class IndexedDBCryptoStore {
     *     timestamp in milliseconds at which the session last received
     *     a message.
     */
-    getEndToEndSession(deviceKey, sessionId, txn, func) {
-        this._backend.getEndToEndSession(deviceKey, sessionId, txn, func);
+    public getEndToEndSession(
+        deviceKey: string,
+        sessionId: string,
+        txn: IDBTransaction,
+        func: (sessions: { [ sessionId: string ]: ISessionInfo }) => void,
+    ): void {
+        this.backend.getEndToEndSession(deviceKey, sessionId, txn, func);
    }

    /**
@@ -387,8 +425,12 @@ export class IndexedDBCryptoStore {
     *     timestamp in milliseconds at which the session last received
     *     a message.
     */
-    getEndToEndSessions(deviceKey, txn, func) {
-        this._backend.getEndToEndSessions(deviceKey, txn, func);
+    public getEndToEndSessions(
+        deviceKey: string,
+        txn: IDBTransaction,
+        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,
+    ): void {
+        this.backend.getEndToEndSessions(deviceKey, txn, func);
    }

    /**
@@ -398,8 +440,8 @@ export class IndexedDBCryptoStore {
     *     an object with, deviceKey, lastReceivedMessageTs, sessionId
     *     and session keys.
     */
-    getAllEndToEndSessions(txn, func) {
-        this._backend.getAllEndToEndSessions(txn, func);
+    public getAllEndToEndSessions(txn: IDBTransaction, func: (session: ISessionInfo) => void): void {
+        this.backend.getAllEndToEndSessions(txn, func);
    }

    /**
@@ -409,22 +451,25 @@ export class IndexedDBCryptoStore {
     * @param {string} sessionInfo Session information object
     * @param {*} txn An active transaction. See doTxn().
     */
-    storeEndToEndSession(deviceKey, sessionId, sessionInfo, txn) {
-        this._backend.storeEndToEndSession(
-            deviceKey, sessionId, sessionInfo, txn,
-        );
+    public storeEndToEndSession(
+        deviceKey: string,
+        sessionId: string,
+        sessionInfo: ISessionInfo,
+        txn: IDBTransaction,
+    ): void {
+        this.backend.storeEndToEndSession(deviceKey, sessionId, sessionInfo, txn);
    }

-    storeEndToEndSessionProblem(deviceKey, type, fixed) {
-        return this._backend.storeEndToEndSessionProblem(deviceKey, type, fixed);
+    public storeEndToEndSessionProblem(deviceKey: string, type: string, fixed: boolean): Promise<void> {
+        return this.backend.storeEndToEndSessionProblem(deviceKey, type, fixed);
    }

-    getEndToEndSessionProblem(deviceKey, timestamp) {
-        return this._backend.getEndToEndSessionProblem(deviceKey, timestamp);
+    public getEndToEndSessionProblem(deviceKey: string, timestamp: number): Promise<IProblem | null> {
+        return this.backend.getEndToEndSessionProblem(deviceKey, timestamp);
    }

-    filterOutNotifiedErrorDevices(devices) {
-        return this._backend.filterOutNotifiedErrorDevices(devices);
+    public filterOutNotifiedErrorDevices(devices: IOlmDevice[]): Promise<IOlmDevice[]> {
+        return this.backend.filterOutNotifiedErrorDevices(devices);
    }

    // Inbound group sessions
@@ -438,10 +483,13 @@ export class IndexedDBCryptoStore {
     * @param {function(object)} func Called with A map from sessionId
     *     to Base64 end-to-end session.
     */
-    getEndToEndInboundGroupSession(senderCurve25519Key, sessionId, txn, func) {
-        this._backend.getEndToEndInboundGroupSession(
-            senderCurve25519Key, sessionId, txn, func,
-        );
+    public getEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        txn: IDBTransaction,
+        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,
+    ): void {
+        this.backend.getEndToEndInboundGroupSession(senderCurve25519Key, sessionId, txn, func);
    }

    /**
@@ -451,8 +499,11 @@ export class IndexedDBCryptoStore {
     *     in the store with an object having keys {senderKey, sessionId,
     *     sessionData}, then once with null to indicate the end of the list.
     */
-    getAllEndToEndInboundGroupSessions(txn, func) {
-        this._backend.getAllEndToEndInboundGroupSessions(txn, func);
+    public getAllEndToEndInboundGroupSessions(
+        txn: IDBTransaction,
+        func: (session: ISession | null) => void,
+    ): void {
+        this.backend.getAllEndToEndInboundGroupSessions(txn, func);
    }

    /**
@@ -464,10 +515,13 @@ export class IndexedDBCryptoStore {
     * @param {object} sessionData The session data structure
     * @param {*} txn An active transaction. See doTxn().
     */
-    addEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn) {
-        this._backend.addEndToEndInboundGroupSession(
-            senderCurve25519Key, sessionId, sessionData, txn,
-        );
+    public addEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: IDBTransaction,
+    ): void {
+        this.backend.addEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn);
    }

    /**
@@ -479,18 +533,22 @@ export class IndexedDBCryptoStore {
     * @param {object} sessionData The session data structure
     * @param {*} txn An active transaction. See doTxn().
     */
-    storeEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn) {
-        this._backend.storeEndToEndInboundGroupSession(
-            senderCurve25519Key, sessionId, sessionData, txn,
-        );
+    public storeEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: IDBTransaction,
+    ): void {
+        this.backend.storeEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn);
    }

-    storeEndToEndInboundGroupSessionWithheld(
-        senderCurve25519Key, sessionId, sessionData, txn,
-    ) {
-        this._backend.storeEndToEndInboundGroupSessionWithheld(
-            senderCurve25519Key, sessionId, sessionData, txn,
-        );
+    public storeEndToEndInboundGroupSessionWithheld(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: IWithheld,
+        txn: IDBTransaction,
+    ): void {
+        this.backend.storeEndToEndInboundGroupSessionWithheld(senderCurve25519Key, sessionId, sessionData, txn);
    }

    // End-to-end device tracking
@@ -505,8 +563,8 @@ export class IndexedDBCryptoStore {
     * @param {Object} deviceData
     * @param {*} txn An active transaction. See doTxn().
     */
-    storeEndToEndDeviceData(deviceData, txn) {
-        this._backend.storeEndToEndDeviceData(deviceData, txn);
+    public storeEndToEndDeviceData(deviceData: IDeviceData, txn: IDBTransaction): void {
+        this.backend.storeEndToEndDeviceData(deviceData, txn);
    }

    /**
@@ -516,8 +574,8 @@ export class IndexedDBCryptoStore {
     * @param {function(Object)} func Function called with the
     *     device data
     */
-    getEndToEndDeviceData(txn, func) {
-        this._backend.getEndToEndDeviceData(txn, func);
+    public getEndToEndDeviceData(txn: IDBTransaction, func: (deviceData: IDeviceData | null) => void): void {
+        this.backend.getEndToEndDeviceData(txn, func);
    }

    // End to End Rooms
@@ -528,8 +586,8 @@ export class IndexedDBCryptoStore {
     * @param {object} roomInfo The end-to-end info for the room.
     * @param {*} txn An active transaction. See doTxn().
     */
-    storeEndToEndRoom(roomId, roomInfo, txn) {
-        this._backend.storeEndToEndRoom(roomId, roomInfo, txn);
+    public storeEndToEndRoom(roomId: string, roomInfo: IRoomEncryption, txn: IDBTransaction): void {
+        this.backend.storeEndToEndRoom(roomId, roomInfo, txn);
    }

    /**
@@ -537,20 +595,20 @@ export class IndexedDBCryptoStore {
     * @param {*} txn An active transaction. See doTxn().
     * @param {function(Object)} func Function called with the end to end encrypted rooms
     */
-    getEndToEndRooms(txn, func) {
-        this._backend.getEndToEndRooms(txn, func);
+    public getEndToEndRooms(txn: IDBTransaction, func: (rooms: Record<string, IRoomEncryption>) => void): void {
+        this.backend.getEndToEndRooms(txn, func);
    }

    // session backups

    /**
     * Get the inbound group sessions that need to be backed up.
-     * @param {integer} limit The maximum number of sessions to retrieve.  0
+     * @param {number} limit The maximum number of sessions to retrieve.  0
     * for no limit.
     * @returns {Promise} resolves to an array of inbound group sessions
     */
-    getSessionsNeedingBackup(limit) {
-        return this._backend.getSessionsNeedingBackup(limit);
+    public getSessionsNeedingBackup(limit: number): Promise<ISession[]> {
+        return this.backend.getSessionsNeedingBackup(limit);
    }

    /**
@@ -558,8 +616,8 @@ export class IndexedDBCryptoStore {
     * @param {*} txn An active transaction. See doTxn(). (optional)
     * @returns {Promise} resolves to the number of sessions
     */
-    countSessionsNeedingBackup(txn) {
-        return this._backend.countSessionsNeedingBackup(txn);
+    public countSessionsNeedingBackup(txn?: IDBTransaction): Promise<number> {
+        return this.backend.countSessionsNeedingBackup(txn);
    }

    /**
@@ -568,8 +626,8 @@ export class IndexedDBCryptoStore {
     * @param {*} txn An active transaction. See doTxn(). (optional)
     * @returns {Promise} resolves when the sessions are unmarked
     */
-    unmarkSessionsNeedingBackup(sessions, txn) {
-        return this._backend.unmarkSessionsNeedingBackup(sessions, txn);
+    public unmarkSessionsNeedingBackup(sessions: ISession[], txn?: IDBTransaction): Promise<void> {
+        return this.backend.unmarkSessionsNeedingBackup(sessions, txn);
    }

    /**
@@ -578,8 +636,8 @@ export class IndexedDBCryptoStore {
     * @param {*} txn An active transaction. See doTxn(). (optional)
     * @returns {Promise} resolves when the sessions are marked
     */
-    markSessionsNeedingBackup(sessions, txn) {
-        return this._backend.markSessionsNeedingBackup(sessions, txn);
+    public markSessionsNeedingBackup(sessions: ISession[], txn?: IDBTransaction): Promise<void> {
+        return this.backend.markSessionsNeedingBackup(sessions, txn);
    }

    /**
@@ -589,10 +647,13 @@ export class IndexedDBCryptoStore {
     * @param {string} sessionId The ID of the session
     * @param {*} txn An active transaction. See doTxn(). (optional)
     */
-    addSharedHistoryInboundGroupSession(roomId, senderKey, sessionId, txn) {
-        this._backend.addSharedHistoryInboundGroupSession(
-            roomId, senderKey, sessionId, txn,
-        );
+    public addSharedHistoryInboundGroupSession(
+        roomId: string,
+        senderKey: string,
+        sessionId: string,
+        txn?: IDBTransaction,
+    ): void {
+        this.backend.addSharedHistoryInboundGroupSession(roomId, senderKey, sessionId, txn);
    }

    /**
@@ -601,8 +662,11 @@ export class IndexedDBCryptoStore {
     * @param {*} txn An active transaction. See doTxn(). (optional)
     * @returns {Promise} Resolves to an array of [senderKey, sessionId]
     */
-    getSharedHistoryInboundGroupSessions(roomId, txn) {
-        return this._backend.getSharedHistoryInboundGroupSessions(roomId, txn);
+    public getSharedHistoryInboundGroupSessions(
+        roomId: string,
+        txn?: IDBTransaction,
+    ): Promise<[senderKey: string, sessionId: string][]> {
+        return this.backend.getSharedHistoryInboundGroupSessions(roomId, txn);
    }

    /**
@@ -627,18 +691,7 @@ export class IndexedDBCryptoStore {
     *     reject with that exception. On synchronous backends, the
     *     exception will propagate to the caller of the getFoo method.
     */
-    doTxn(mode, stores, func, log) {
-        return this._backend.doTxn(mode, stores, func, log);
+    doTxn<T>(mode: Mode, stores: Iterable<string>, func: (txn: IDBTransaction) => T, log?: PrefixedLogger): Promise<T> {
+        return this.backend.doTxn(mode, stores, func, log);
    }
 }
-
-IndexedDBCryptoStore.STORE_ACCOUNT = 'account';
-IndexedDBCryptoStore.STORE_SESSIONS = 'sessions';
-IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS = 'inbound_group_sessions';
-IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD
-    = 'inbound_group_sessions_withheld';
-IndexedDBCryptoStore.STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS
-    = 'shared_history_inbound_group_sessions';
-IndexedDBCryptoStore.STORE_DEVICE_DATA = 'device_data';
-IndexedDBCryptoStore.STORE_ROOMS = 'rooms';
-IndexedDBCryptoStore.STORE_BACKUP = 'sessions_needing_backup';
@@ -1,6 +1,5 @@
 /*
-Copyright 2017, 2018 New Vector Ltd
-Copyright 2020 The Matrix.org Foundation C.I.C.
+Copyright 2017 - 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.
@@ -17,6 +16,12 @@ limitations under the License.

 import { logger } from '../../logger';
 import { MemoryCryptoStore } from './memory-crypto-store';
+import { IDeviceData, IProblem, ISession, ISessionInfo, IWithheld, Mode } from "./base";
+import { IOlmDevice } from "../algorithms/megolm";
+import { IRoomEncryption } from "../RoomList";
+import { ICrossSigningKey } from "../../client";
+import { InboundGroupSessionData } from "../OlmDevice";
+import { IEncryptedPayload } from "../aes";

 /**
 * Internal module. Partial localStorage backed storage for e2e.
@@ -38,23 +43,23 @@ const KEY_INBOUND_SESSION_WITHHELD_PREFIX = E2E_PREFIX + "inboundgroupsessions.w
 const KEY_ROOMS_PREFIX = E2E_PREFIX + "rooms/";
 const KEY_SESSIONS_NEEDING_BACKUP = E2E_PREFIX + "sessionsneedingbackup";

-function keyEndToEndSessions(deviceKey) {
+function keyEndToEndSessions(deviceKey: string): string {
    return E2E_PREFIX + "sessions/" + deviceKey;
 }

-function keyEndToEndSessionProblems(deviceKey) {
+function keyEndToEndSessionProblems(deviceKey: string): string {
    return E2E_PREFIX + "session.problems/" + deviceKey;
 }

-function keyEndToEndInboundGroupSession(senderKey, sessionId) {
+function keyEndToEndInboundGroupSession(senderKey: string, sessionId: string): string {
    return KEY_INBOUND_SESSION_PREFIX + senderKey + "/" + sessionId;
 }

-function keyEndToEndInboundGroupSessionWithheld(senderKey, sessionId) {
+function keyEndToEndInboundGroupSessionWithheld(senderKey: string, sessionId: string): string {
    return KEY_INBOUND_SESSION_WITHHELD_PREFIX + senderKey + "/" + sessionId;
 }

-function keyEndToEndRoomsPrefix(roomId) {
+function keyEndToEndRoomsPrefix(roomId: string): string {
    return KEY_ROOMS_PREFIX + roomId;
 }

@@ -62,24 +67,23 @@ function keyEndToEndRoomsPrefix(roomId) {
 * @implements {module:crypto/store/base~CryptoStore}
 */
 export class LocalStorageCryptoStore extends MemoryCryptoStore {
-    constructor(webStore) {
-        super();
-        this.store = webStore;
-    }
-
-    static exists(webStore) {
-        const length = webStore.length;
+    public static exists(store: Storage): boolean {
+        const length = store.length;
        for (let i = 0; i < length; i++) {
-            if (webStore.key(i).startsWith(E2E_PREFIX)) {
+            if (store.key(i).startsWith(E2E_PREFIX)) {
                return true;
            }
        }
        return false;
    }

+    constructor(private readonly store: Storage) {
+        super();
+    }
+
    // Olm Sessions

-    countEndToEndSessions(txn, func) {
+    public countEndToEndSessions(txn: unknown, func: (count: number) => void): void {
        let count = 0;
        for (let i = 0; i < this.store.length; ++i) {
            if (this.store.key(i).startsWith(keyEndToEndSessions(''))) ++count;
@@ -87,9 +91,10 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        func(count);
    }

-    _getEndToEndSessions(deviceKey, txn, func) {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    private _getEndToEndSessions(deviceKey: string): Record<string, ISessionInfo> {
        const sessions = getJsonItem(this.store, keyEndToEndSessions(deviceKey));
-        const fixedSessions = {};
+        const fixedSessions: Record<string, ISessionInfo> = {};

        // fix up any old sessions to be objects rather than just the base64 pickle
        for (const [sid, val] of Object.entries(sessions || {})) {
@@ -105,16 +110,25 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        return fixedSessions;
    }

-    getEndToEndSession(deviceKey, sessionId, txn, func) {
+    public getEndToEndSession(
+        deviceKey: string,
+        sessionId: string,
+        txn: unknown,
+        func: (session: ISessionInfo) => void,
+    ): void {
        const sessions = this._getEndToEndSessions(deviceKey);
        func(sessions[sessionId] || {});
    }

-    getEndToEndSessions(deviceKey, txn, func) {
+    public getEndToEndSessions(
+        deviceKey: string,
+        txn: unknown,
+        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,
+    ): void {
        func(this._getEndToEndSessions(deviceKey) || {});
    }

-    getAllEndToEndSessions(txn, func) {
+    public getAllEndToEndSessions(txn: unknown, func: (session: ISessionInfo) => void): void {
        for (let i = 0; i < this.store.length; ++i) {
            if (this.store.key(i).startsWith(keyEndToEndSessions(''))) {
                const deviceKey = this.store.key(i).split('/')[1];
@@ -125,17 +139,15 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        }
    }

-    storeEndToEndSession(deviceKey, sessionId, sessionInfo, txn) {
+    public storeEndToEndSession(deviceKey: string, sessionId: string, sessionInfo: ISessionInfo, txn: unknown): void {
        const sessions = this._getEndToEndSessions(deviceKey) || {};
        sessions[sessionId] = sessionInfo;
-        setJsonItem(
-            this.store, keyEndToEndSessions(deviceKey), sessions,
-        );
+        setJsonItem(this.store, keyEndToEndSessions(deviceKey), sessions);
    }

-    async storeEndToEndSessionProblem(deviceKey, type, fixed) {
+    public async storeEndToEndSessionProblem(deviceKey: string, type: string, fixed: boolean): Promise<void> {
        const key = keyEndToEndSessionProblems(deviceKey);
-        const problems = getJsonItem(this.store, key) || [];
+        const problems = getJsonItem<IProblem[]>(this.store, key) || [];
        problems.push({ type, fixed, time: Date.now() });
        problems.sort((a, b) => {
            return a.time - b.time;
@@ -143,9 +155,9 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        setJsonItem(this.store, key, problems);
    }

-    async getEndToEndSessionProblem(deviceKey, timestamp) {
+    async getEndToEndSessionProblem(deviceKey: string, timestamp: number): Promise<IProblem | null> {
        const key = keyEndToEndSessionProblems(deviceKey);
-        const problems = getJsonItem(this.store, key) || [];
+        const problems = getJsonItem<IProblem[]>(this.store, key) || [];
        if (!problems.length) {
            return null;
        }
@@ -162,9 +174,8 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        }
    }

-    async filterOutNotifiedErrorDevices(devices) {
-        const notifiedErrorDevices =
-              getJsonItem(this.store, KEY_NOTIFIED_ERROR_DEVICES) || {};
+    public async filterOutNotifiedErrorDevices(devices: IOlmDevice[]): Promise<IOlmDevice[]> {
+        const notifiedErrorDevices = getJsonItem<string[]>(this.store, KEY_NOTIFIED_ERROR_DEVICES) || {};
        const ret = [];

        for (const device of devices) {
@@ -187,7 +198,12 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {

    // Inbound Group Sessions

-    getEndToEndInboundGroupSession(senderCurve25519Key, sessionId, txn, func) {
+    public getEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        txn: unknown,
+        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,
+    ): void {
        func(
            getJsonItem(
                this.store,
@@ -200,7 +216,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        );
    }

-    getAllEndToEndInboundGroupSessions(txn, func) {
+    public getAllEndToEndInboundGroupSessions(txn: unknown, func: (session: ISession | null) => void): void {
        for (let i = 0; i < this.store.length; ++i) {
            const key = this.store.key(i);
            if (key.startsWith(KEY_INBOUND_SESSION_PREFIX)) {
@@ -219,7 +235,12 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        func(null);
    }

-    addEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn) {
+    public addEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: unknown,
+    ): void {
        const existing = getJsonItem(
            this.store,
            keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId),
@@ -231,7 +252,12 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        }
    }

-    storeEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn) {
+    public storeEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: unknown,
+    ): void {
        setJsonItem(
            this.store,
            keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId),
@@ -239,9 +265,12 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        );
    }

-    storeEndToEndInboundGroupSessionWithheld(
-        senderCurve25519Key, sessionId, sessionData, txn,
-    ) {
+    public storeEndToEndInboundGroupSessionWithheld(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: IWithheld,
+        txn: unknown,
+    ): void {
        setJsonItem(
            this.store,
            keyEndToEndInboundGroupSessionWithheld(senderCurve25519Key, sessionId),
@@ -249,25 +278,19 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        );
    }

-    getEndToEndDeviceData(txn, func) {
-        func(getJsonItem(
-            this.store, KEY_DEVICE_DATA,
-        ));
+    public getEndToEndDeviceData(txn: unknown, func: (deviceData: IDeviceData | null) => void): void {
+        func(getJsonItem(this.store, KEY_DEVICE_DATA));
    }

-    storeEndToEndDeviceData(deviceData, txn) {
-        setJsonItem(
-            this.store, KEY_DEVICE_DATA, deviceData,
-        );
+    public storeEndToEndDeviceData(deviceData: IDeviceData, txn: unknown): void {
+        setJsonItem(this.store, KEY_DEVICE_DATA, deviceData);
    }

-    storeEndToEndRoom(roomId, roomInfo, txn) {
-        setJsonItem(
-            this.store, keyEndToEndRoomsPrefix(roomId), roomInfo,
-        );
+    public storeEndToEndRoom(roomId: string, roomInfo: IRoomEncryption, txn: unknown): void {
+        setJsonItem(this.store, keyEndToEndRoomsPrefix(roomId), roomInfo);
    }

-    getEndToEndRooms(txn, func) {
+    public getEndToEndRooms(txn: unknown, func: (rooms: Record<string, IRoomEncryption>) => void): void {
        const result = {};
        const prefix = keyEndToEndRoomsPrefix('');

@@ -281,9 +304,8 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        func(result);
    }

-    getSessionsNeedingBackup(limit) {
-        const sessionsNeedingBackup
-              = getJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
+    public getSessionsNeedingBackup(limit: number): Promise<ISession[]> {
+        const sessionsNeedingBackup = getJsonItem<string[]>(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
        const sessions = [];

        for (const session in sessionsNeedingBackup) {
@@ -309,13 +331,12 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        return Promise.resolve(sessions);
    }

-    countSessionsNeedingBackup() {
-        const sessionsNeedingBackup
-              = getJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
+    public countSessionsNeedingBackup(): Promise<number> {
+        const sessionsNeedingBackup = getJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
        return Promise.resolve(Object.keys(sessionsNeedingBackup).length);
    }

-    unmarkSessionsNeedingBackup(sessions) {
+    public unmarkSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
        const sessionsNeedingBackup
              = getJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
        for (const session of sessions) {
@@ -327,7 +348,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        return Promise.resolve();
    }

-    markSessionsNeedingBackup(sessions) {
+    public markSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
        const sessionsNeedingBackup
              = getJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
        for (const session of sessions) {
@@ -344,52 +365,46 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
     *
     * @returns {Promise} Promise which resolves when the store has been cleared.
     */
-    deleteAllData() {
+    public deleteAllData(): Promise<void> {
        this.store.removeItem(KEY_END_TO_END_ACCOUNT);
        return Promise.resolve();
    }

    // Olm account

-    getAccount(txn, func) {
-        const account = getJsonItem(this.store, KEY_END_TO_END_ACCOUNT);
-        func(account);
+    public getAccount(txn: unknown, func: (accountPickle: string) => void): void {
+        const accountPickle = getJsonItem<string>(this.store, KEY_END_TO_END_ACCOUNT);
+        func(accountPickle);
    }

-    storeAccount(txn, newData) {
-        setJsonItem(
-            this.store, KEY_END_TO_END_ACCOUNT, newData,
-        );
+    public storeAccount(txn: unknown, accountPickle: string): void {
+        setJsonItem(this.store, KEY_END_TO_END_ACCOUNT, accountPickle);
    }

-    getCrossSigningKeys(txn, func) {
-        const keys = getJsonItem(this.store, KEY_CROSS_SIGNING_KEYS);
+    public getCrossSigningKeys(txn: unknown, func: (keys: Record<string, ICrossSigningKey>) => void): void {
+        const keys = getJsonItem<Record<string, ICrossSigningKey>>(this.store, KEY_CROSS_SIGNING_KEYS);
        func(keys);
    }

-    getSecretStorePrivateKey(txn, func, type) {
-        const key = getJsonItem(this.store, E2E_PREFIX + `ssss_cache.${type}`);
+    public getSecretStorePrivateKey(txn: unknown, func: (key: IEncryptedPayload | null) => void, type: string): void {
+        const key = getJsonItem<IEncryptedPayload>(this.store, E2E_PREFIX + `ssss_cache.${type}`);
        func(key);
    }

-    storeCrossSigningKeys(txn, keys) {
-        setJsonItem(
-            this.store, KEY_CROSS_SIGNING_KEYS, keys,
-        );
+    public storeCrossSigningKeys(txn: unknown, keys: Record<string, ICrossSigningKey>): void {
+        setJsonItem(this.store, KEY_CROSS_SIGNING_KEYS, keys);
    }

-    storeSecretStorePrivateKey(txn, type, key) {
-        setJsonItem(
-            this.store, E2E_PREFIX + `ssss_cache.${type}`, key,
-        );
+    public storeSecretStorePrivateKey(txn: unknown, type: string, key: IEncryptedPayload): void {
+        setJsonItem(this.store, E2E_PREFIX + `ssss_cache.${type}`, key);
    }

-    doTxn(mode, stores, func) {
+    doTxn<T>(mode: Mode, stores: Iterable<string>, func: (txn: unknown) => T): Promise<T> {
        return Promise.resolve(func(null));
    }
 }

-function getJsonItem(store, key) {
+function getJsonItem<T>(store: Storage, key: string): T | null {
    try {
        // if the key is absent, store.getItem() returns null, and
        // JSON.parse(null) === null, so this returns null.
@@ -401,6 +416,6 @@ function getJsonItem(store, key) {
    return null;
 }

-function setJsonItem(store, key, val) {
+function setJsonItem<T>(store: Storage, key: string, val: T): void {
    store.setItem(key, JSON.stringify(val));
 }
@@ -1,7 +1,5 @@
 /*
-Copyright 2017 Vector Creations Ltd
-Copyright 2018 New Vector Ltd
-Copyright 2020 The Matrix.org Foundation C.I.C.
+Copyright 2017 - 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.
@@ -18,6 +16,22 @@ limitations under the License.

 import { logger } from '../../logger';
 import * as utils from "../../utils";
+import {
+    CryptoStore,
+    IDeviceData,
+    IProblem,
+    ISession,
+    ISessionInfo,
+    IWithheld,
+    Mode,
+    OutgoingRoomKeyRequest,
+} from "./base";
+import { IRoomKeyRequestBody } from "../index";
+import { ICrossSigningKey } from "../../client";
+import { IOlmDevice } from "../algorithms/megolm";
+import { IRoomEncryption } from "../RoomList";
+import { InboundGroupSessionData } from "../OlmDevice";
+import { IEncryptedPayload } from "../aes";

 /**
 * Internal module. in-memory storage for e2e.
@@ -28,32 +42,22 @@ import * as utils from "../../utils";
 /**
 * @implements {module:crypto/store/base~CryptoStore}
 */
-export class MemoryCryptoStore {
-    constructor() {
-        this._outgoingRoomKeyRequests = [];
-        this._account = null;
-        this._crossSigningKeys = null;
-        this._privateKeys = {};
-        this._backupKeys = {};
+export class MemoryCryptoStore implements CryptoStore {
+    private outgoingRoomKeyRequests: OutgoingRoomKeyRequest[] = [];
+    private account: string = null;
+    private crossSigningKeys: Record<string, ICrossSigningKey> = null;
+    private privateKeys: Record<string, IEncryptedPayload> = {};

-        // Map of {devicekey -> {sessionId -> session pickle}}
-        this._sessions = {};
-        // Map of {devicekey -> array of problems}
-        this._sessionProblems = {};
-        // Map of {userId -> deviceId -> true}
-        this._notifiedErrorDevices = {};
-        // Map of {senderCurve25519Key+'/'+sessionId -> session data object}
-        this._inboundGroupSessions = {};
-        this._inboundGroupSessionsWithheld = {};
-        // Opaque device data object
-        this._deviceData = null;
-        // roomId -> Opaque roomInfo object
-        this._rooms = {};
-        // Set of {senderCurve25519Key+'/'+sessionId}
-        this._sessionsNeedingBackup = {};
-        // roomId -> array of [senderKey, sessionId]
-        this._sharedHistoryInboundGroupSessions = {};
-    }
+    private sessions: { [deviceKey: string]: { [sessionId: string]: ISessionInfo } } = {};
+    private sessionProblems: { [deviceKey: string]: IProblem[] } = {};
+    private notifiedErrorDevices: { [userId: string]: { [deviceId: string]: boolean } } = {};
+    private inboundGroupSessions: { [sessionKey: string]: InboundGroupSessionData } = {};
+    private inboundGroupSessionsWithheld: Record<string, IWithheld> = {};
+    // Opaque device data object
+    private deviceData: IDeviceData = null;
+    private rooms: { [roomId: string]: IRoomEncryption } = {};
+    private sessionsNeedingBackup: { [sessionKey: string]: boolean } = {};
+    private sharedHistoryInboundGroupSessions: { [roomId: string]: [senderKey: string, sessionId: string][] } = {};

    /**
     * Ensure the database exists and is up-to-date.
@@ -62,7 +66,7 @@ export class MemoryCryptoStore {
     *
     * @return {Promise} resolves to the store.
     */
-    async startup() {
+    public async startup(): Promise<CryptoStore> {
        // No startup work to do for the memory store.
        return this;
    }
@@ -72,7 +76,7 @@ export class MemoryCryptoStore {
     *
     * @returns {Promise} Promise which resolves when the store has been cleared.
     */
-    deleteAllData() {
+    public deleteAllData(): Promise<void> {
        return Promise.resolve();
    }

@@ -86,7 +90,7 @@ export class MemoryCryptoStore {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}: either the
     *    same instance as passed in, or the existing one.
     */
-    getOrAddOutgoingRoomKeyRequest(request) {
+    public getOrAddOutgoingRoomKeyRequest(request: OutgoingRoomKeyRequest): Promise<OutgoingRoomKeyRequest> {
        const requestBody = request.requestBody;

        return utils.promiseTry(() => {
@@ -109,7 +113,7 @@ export class MemoryCryptoStore {
                `enqueueing key request for ${requestBody.room_id} / ` +
                requestBody.session_id,
            );
-            this._outgoingRoomKeyRequests.push(request);
+            this.outgoingRoomKeyRequests.push(request);
            return request;
        });
    }
@@ -124,7 +128,7 @@ export class MemoryCryptoStore {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
     *    not found
     */
-    getOutgoingRoomKeyRequest(requestBody) {
+    public getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<OutgoingRoomKeyRequest | null> {
        return Promise.resolve(this._getOutgoingRoomKeyRequest(requestBody));
    }

@@ -139,8 +143,9 @@ export class MemoryCryptoStore {
     * @return {module:crypto/store/base~OutgoingRoomKeyRequest?}
     *    the matching request, or null if not found
     */
-    _getOutgoingRoomKeyRequest(requestBody) {
-        for (const existing of this._outgoingRoomKeyRequests) {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    private _getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): OutgoingRoomKeyRequest | null {
+        for (const existing of this.outgoingRoomKeyRequests) {
            if (utils.deepCompare(existing.requestBody, requestBody)) {
                return existing;
            }
@@ -157,8 +162,8 @@ export class MemoryCryptoStore {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
     *    there are no pending requests in those states
     */
-    getOutgoingRoomKeyRequestByState(wantedStates) {
-        for (const req of this._outgoingRoomKeyRequests) {
+    public getOutgoingRoomKeyRequestByState(wantedStates: number[]): Promise<OutgoingRoomKeyRequest | null> {
+        for (const req of this.outgoingRoomKeyRequests) {
            for (const state of wantedStates) {
                if (req.state === state) {
                    return Promise.resolve(req);
@@ -173,18 +178,22 @@ export class MemoryCryptoStore {
     * @param {Number} wantedState
     * @return {Promise<Array<*>>} All OutgoingRoomKeyRequests in state
     */
-    getAllOutgoingRoomKeyRequestsByState(wantedState) {
+    public getAllOutgoingRoomKeyRequestsByState(wantedState: number): Promise<OutgoingRoomKeyRequest[]> {
        return Promise.resolve(
-            this._outgoingRoomKeyRequests.filter(
+            this.outgoingRoomKeyRequests.filter(
                (r) => r.state == wantedState,
            ),
        );
    }

-    getOutgoingRoomKeyRequestsByTarget(userId, deviceId, wantedStates) {
+    public getOutgoingRoomKeyRequestsByTarget(
+        userId: string,
+        deviceId: string,
+        wantedStates: number[],
+    ): Promise<OutgoingRoomKeyRequest[]> {
        const results = [];

-        for (const req of this._outgoingRoomKeyRequests) {
+        for (const req of this.outgoingRoomKeyRequests) {
            for (const state of wantedStates) {
                if (req.state === state && req.recipients.includes({ userId, deviceId })) {
                    results.push(req);
@@ -206,13 +215,17 @@ export class MemoryCryptoStore {
     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
     *    updated request, or null if no matching row was found
     */
-    updateOutgoingRoomKeyRequest(requestId, expectedState, updates) {
-        for (const req of this._outgoingRoomKeyRequests) {
+    public updateOutgoingRoomKeyRequest(
+        requestId: string,
+        expectedState: number,
+        updates: Partial<OutgoingRoomKeyRequest>,
+    ): Promise<OutgoingRoomKeyRequest | null> {
+        for (const req of this.outgoingRoomKeyRequests) {
            if (req.requestId !== requestId) {
                continue;
            }

-            if (req.state != expectedState) {
+            if (req.state !== expectedState) {
                logger.warn(
                    `Cannot update room key request from ${expectedState} ` +
                    `as it was already updated to ${req.state}`,
@@ -235,9 +248,12 @@ export class MemoryCryptoStore {
     *
     * @returns {Promise} resolves once the operation is completed
     */
-    deleteOutgoingRoomKeyRequest(requestId, expectedState) {
-        for (let i = 0; i < this._outgoingRoomKeyRequests.length; i++) {
-            const req = this._outgoingRoomKeyRequests[i];
+    public deleteOutgoingRoomKeyRequest(
+        requestId: string,
+        expectedState: number,
+    ): Promise<OutgoingRoomKeyRequest | null> {
+        for (let i = 0; i < this.outgoingRoomKeyRequests.length; i++) {
+            const req = this.outgoingRoomKeyRequests[i];

            if (req.requestId !== requestId) {
                continue;
@@ -251,7 +267,7 @@ export class MemoryCryptoStore {
                return Promise.resolve(null);
            }

-            this._outgoingRoomKeyRequests.splice(i, 1);
+            this.outgoingRoomKeyRequests.splice(i, 1);
            return Promise.resolve(req);
        }

@@ -260,48 +276,57 @@ export class MemoryCryptoStore {

    // Olm Account

-    getAccount(txn, func) {
-        func(this._account);
+    public getAccount(txn: unknown, func: (accountPickle: string) => void) {
+        func(this.account);
    }

-    storeAccount(txn, newData) {
-        this._account = newData;
+    public storeAccount(txn: unknown, accountPickle: string): void {
+        this.account = accountPickle;
    }

-    getCrossSigningKeys(txn, func) {
-        func(this._crossSigningKeys);
+    public getCrossSigningKeys(txn: unknown, func: (keys: Record<string, ICrossSigningKey>) => void): void {
+        func(this.crossSigningKeys);
    }

-    getSecretStorePrivateKey(txn, func, type) {
-        const result = this._privateKeys[type];
-        return func(result || null);
+    public getSecretStorePrivateKey(txn: unknown, func: (key: IEncryptedPayload | null) => void, type: string): void {
+        const result = this.privateKeys[type];
+        func(result || null);
    }

-    storeCrossSigningKeys(txn, keys) {
-        this._crossSigningKeys = keys;
+    public storeCrossSigningKeys(txn: unknown, keys: Record<string, ICrossSigningKey>): void {
+        this.crossSigningKeys = keys;
    }

-    storeSecretStorePrivateKey(txn, type, key) {
-        this._privateKeys[type] = key;
+    public storeSecretStorePrivateKey(txn: unknown, type: string, key: IEncryptedPayload): void {
+        this.privateKeys[type] = key;
    }

    // Olm Sessions

-    countEndToEndSessions(txn, func) {
-        return Object.keys(this._sessions).length;
+    public countEndToEndSessions(txn: unknown, func: (count: number) => void): void {
+        func(Object.keys(this.sessions).length);
    }

-    getEndToEndSession(deviceKey, sessionId, txn, func) {
-        const deviceSessions = this._sessions[deviceKey] || {};
+    public getEndToEndSession(
+        deviceKey: string,
+        sessionId: string,
+        txn: unknown,
+        func: (session: ISessionInfo) => void,
+    ): void {
+        const deviceSessions = this.sessions[deviceKey] || {};
        func(deviceSessions[sessionId] || null);
    }

-    getEndToEndSessions(deviceKey, txn, func) {
-        func(this._sessions[deviceKey] || {});
+    public getEndToEndSessions(
+        deviceKey: string,
+        txn: unknown,
+        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,
+    ): void {
+        func(this.sessions[deviceKey] || {});
    }

-    getAllEndToEndSessions(txn, func) {
-        Object.entries(this._sessions).forEach(([deviceKey, deviceSessions]) => {
+    public getAllEndToEndSessions(txn: unknown, func: (session: ISessionInfo) => void): void {
+        Object.entries(this.sessions).forEach(([deviceKey, deviceSessions]) => {
            Object.entries(deviceSessions).forEach(([sessionId, session]) => {
                func({
                    ...session,
@@ -312,26 +337,25 @@ export class MemoryCryptoStore {
        });
    }

-    storeEndToEndSession(deviceKey, sessionId, sessionInfo, txn) {
-        let deviceSessions = this._sessions[deviceKey];
+    public storeEndToEndSession(deviceKey: string, sessionId: string, sessionInfo: ISessionInfo, txn: unknown): void {
+        let deviceSessions = this.sessions[deviceKey];
        if (deviceSessions === undefined) {
            deviceSessions = {};
-            this._sessions[deviceKey] = deviceSessions;
+            this.sessions[deviceKey] = deviceSessions;
        }
        deviceSessions[sessionId] = sessionInfo;
    }

-    async storeEndToEndSessionProblem(deviceKey, type, fixed) {
-        const problems = this._sessionProblems[deviceKey]
-              = this._sessionProblems[deviceKey] || [];
+    public async storeEndToEndSessionProblem(deviceKey: string, type: string, fixed: boolean): Promise<void> {
+        const problems = this.sessionProblems[deviceKey] = this.sessionProblems[deviceKey] || [];
        problems.push({ type, fixed, time: Date.now() });
        problems.sort((a, b) => {
            return a.time - b.time;
        });
    }

-    async getEndToEndSessionProblem(deviceKey, timestamp) {
-        const problems = this._sessionProblems[deviceKey] || [];
+    public async getEndToEndSessionProblem(deviceKey: string, timestamp: number): Promise<IProblem | null> {
+        const problems = this.sessionProblems[deviceKey] || [];
        if (!problems.length) {
            return null;
        }
@@ -348,9 +372,9 @@ export class MemoryCryptoStore {
        }
    }

-    async filterOutNotifiedErrorDevices(devices) {
-        const notifiedErrorDevices = this._notifiedErrorDevices;
-        const ret = [];
+    public async filterOutNotifiedErrorDevices(devices: IOlmDevice[]): Promise<IOlmDevice[]> {
+        const notifiedErrorDevices = this.notifiedErrorDevices;
+        const ret: IOlmDevice[] = [];

        for (const device of devices) {
            const { userId, deviceInfo } = device;
@@ -370,16 +394,24 @@ export class MemoryCryptoStore {

    // Inbound Group Sessions

-    getEndToEndInboundGroupSession(senderCurve25519Key, sessionId, txn, func) {
+    public getEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        txn: unknown,
+        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,
+    ): void {
        const k = senderCurve25519Key+'/'+sessionId;
        func(
-            this._inboundGroupSessions[k] || null,
-            this._inboundGroupSessionsWithheld[k] || null,
+            this.inboundGroupSessions[k] || null,
+            this.inboundGroupSessionsWithheld[k] || null,
        );
    }

-    getAllEndToEndInboundGroupSessions(txn, func) {
-        for (const key of Object.keys(this._inboundGroupSessions)) {
+    public getAllEndToEndInboundGroupSessions(
+        txn: unknown,
+        func: (session: ISession | null) => void,
+    ): void {
+        for (const key of Object.keys(this.inboundGroupSessions)) {
            // we can't use split, as the components we are trying to split out
            // might themselves contain '/' characters. We rely on the
            // senderKey being a (32-byte) curve25519 key, base64-encoded
@@ -388,58 +420,71 @@ export class MemoryCryptoStore {
            func({
                senderKey: key.substr(0, 43),
                sessionId: key.substr(44),
-                sessionData: this._inboundGroupSessions[key],
+                sessionData: this.inboundGroupSessions[key],
            });
        }
        func(null);
    }

-    addEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn) {
+    public addEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: unknown,
+    ): void {
        const k = senderCurve25519Key+'/'+sessionId;
-        if (this._inboundGroupSessions[k] === undefined) {
-            this._inboundGroupSessions[k] = sessionData;
+        if (this.inboundGroupSessions[k] === undefined) {
+            this.inboundGroupSessions[k] = sessionData;
        }
    }

-    storeEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn) {
-        this._inboundGroupSessions[senderCurve25519Key+'/'+sessionId] = sessionData;
+    public storeEndToEndInboundGroupSession(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: InboundGroupSessionData,
+        txn: unknown,
+    ): void {
+        this.inboundGroupSessions[senderCurve25519Key+'/'+sessionId] = sessionData;
    }

-    storeEndToEndInboundGroupSessionWithheld(
-        senderCurve25519Key, sessionId, sessionData, txn,
-    ) {
+    public storeEndToEndInboundGroupSessionWithheld(
+        senderCurve25519Key: string,
+        sessionId: string,
+        sessionData: IWithheld,
+        txn: unknown,
+    ): void {
        const k = senderCurve25519Key+'/'+sessionId;
-        this._inboundGroupSessionsWithheld[k] = sessionData;
+        this.inboundGroupSessionsWithheld[k] = sessionData;
    }

    // Device Data

-    getEndToEndDeviceData(txn, func) {
-        func(this._deviceData);
+    public getEndToEndDeviceData(txn: unknown, func: (deviceData: IDeviceData | null) => void): void {
+        func(this.deviceData);
    }

-    storeEndToEndDeviceData(deviceData, txn) {
-        this._deviceData = deviceData;
+    public storeEndToEndDeviceData(deviceData: IDeviceData, txn: unknown): void {
+        this.deviceData = deviceData;
    }

    // E2E rooms

-    storeEndToEndRoom(roomId, roomInfo, txn) {
-        this._rooms[roomId] = roomInfo;
+    public storeEndToEndRoom(roomId: string, roomInfo: IRoomEncryption, txn: unknown): void {
+        this.rooms[roomId] = roomInfo;
    }

-    getEndToEndRooms(txn, func) {
-        func(this._rooms);
+    public getEndToEndRooms(txn: unknown, func: (rooms: Record<string, IRoomEncryption>) => void): void {
+        func(this.rooms);
    }

-    getSessionsNeedingBackup(limit) {
-        const sessions = [];
-        for (const session in this._sessionsNeedingBackup) {
-            if (this._inboundGroupSessions[session]) {
+    public getSessionsNeedingBackup(limit: number): Promise<ISession[]> {
+        const sessions: ISession[] = [];
+        for (const session in this.sessionsNeedingBackup) {
+            if (this.inboundGroupSessions[session]) {
                sessions.push({
                    senderKey: session.substr(0, 43),
                    sessionId: session.substr(44),
-                    sessionData: this._inboundGroupSessions[session],
+                    sessionData: this.inboundGroupSessions[session],
                });
                if (limit && session.length >= limit) {
                    break;
@@ -449,39 +494,39 @@ export class MemoryCryptoStore {
        return Promise.resolve(sessions);
    }

-    countSessionsNeedingBackup() {
-        return Promise.resolve(Object.keys(this._sessionsNeedingBackup).length);
+    public countSessionsNeedingBackup(): Promise<number> {
+        return Promise.resolve(Object.keys(this.sessionsNeedingBackup).length);
    }

-    unmarkSessionsNeedingBackup(sessions) {
+    public unmarkSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
        for (const session of sessions) {
            const sessionKey = session.senderKey + '/' + session.sessionId;
-            delete this._sessionsNeedingBackup[sessionKey];
+            delete this.sessionsNeedingBackup[sessionKey];
        }
        return Promise.resolve();
    }

-    markSessionsNeedingBackup(sessions) {
+    public markSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
        for (const session of sessions) {
            const sessionKey = session.senderKey + '/' + session.sessionId;
-            this._sessionsNeedingBackup[sessionKey] = true;
+            this.sessionsNeedingBackup[sessionKey] = true;
        }
        return Promise.resolve();
    }

-    addSharedHistoryInboundGroupSession(roomId, senderKey, sessionId) {
-        const sessions = this._sharedHistoryInboundGroupSessions[roomId] || [];
+    public addSharedHistoryInboundGroupSession(roomId: string, senderKey: string, sessionId: string): void {
+        const sessions = this.sharedHistoryInboundGroupSessions[roomId] || [];
        sessions.push([senderKey, sessionId]);
-        this._sharedHistoryInboundGroupSessions[roomId] = sessions;
+        this.sharedHistoryInboundGroupSessions[roomId] = sessions;
    }

-    getSharedHistoryInboundGroupSessions(roomId) {
-        return Promise.resolve(this._sharedHistoryInboundGroupSessions[roomId] || []);
+    public getSharedHistoryInboundGroupSessions(roomId: string): Promise<[senderKey: string, sessionId: string][]> {
+        return Promise.resolve(this.sharedHistoryInboundGroupSessions[roomId] || []);
    }

    // Session key backups

-    doTxn(mode, stores, func) {
+    public doTxn<T>(mode: Mode, stores: Iterable<string>, func: (txn?: unknown) => T): Promise<T> {
        return Promise.resolve(func(null));
    }
 }
@@ -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) {
-            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);
    }
 }
@@ -15,9 +15,9 @@ limitations under the License.
 */

 import { MatrixClient } from "./client";
-import { MatrixEvent } from "./models/event";
+import { IEvent, MatrixEvent } from "./models/event";

-export type EventMapper = (obj: any) => MatrixEvent;
+export type EventMapper = (obj: Partial<IEvent>) => MatrixEvent;

 export interface MapperOpts {
    preventReEmit?: boolean;
@@ -28,7 +28,7 @@ export function eventMapperFor(client: MatrixClient, options: MapperOpts): Event
    const preventReEmit = Boolean(options.preventReEmit);
    const decrypt = options.decrypt !== false;

-    function mapper(plainOldJsObject) {
+    function mapper(plainOldJsObject: Partial<IEvent>) {
        const event = new MatrixEvent(plainOldJsObject);
        if (event.isEncrypted()) {
            if (!preventReEmit) {
@@ -39,7 +39,7 @@ function setProp(obj: object, keyNesting: string, val: any) {
 }

 /* eslint-disable camelcase */
-interface IFilterDefinition {
+export interface IFilterDefinition {
    event_fields?: string[];
    event_format?: "client" | "federation";
    presence?: IFilterComponent;
@@ -47,7 +47,7 @@ interface IFilterDefinition {
    room?: IRoomFilter;
 }

-interface IRoomEventFilter extends IFilterComponent {
+export interface IRoomEventFilter extends IFilterComponent {
    lazy_load_members?: boolean;
    include_redundant_members?: boolean;
 }
@@ -86,7 +86,7 @@ export class Filter {
     * @param {Object} jsonObj
     * @return {Filter}
     */
-    static fromJson(userId: string, filterId: string, jsonObj: IFilterDefinition): Filter {
+    public static fromJson(userId: string, filterId: string, jsonObj: IFilterDefinition): Filter {
        const filter = new Filter(userId, filterId);
        filter.setDefinition(jsonObj);
        return filter;
@@ -121,7 +121,7 @@ MatrixHttpApi.prototype = {
    },

    /**
-     * Upload content to the Home Server
+     * Upload content to the homeserver
     *
     * @param {object} file The object to upload. On a browser, something that
     *   can be sent to XMLHttpRequest.send (typically a File).  Under node.js,
@@ -393,7 +393,7 @@ MatrixHttpApi.prototype = {
        accessToken,
    ) {
        if (!this.opts.idBaseUrl) {
-            throw new Error("No Identity Server base URL set");
+            throw new Error("No identity server base URL set");
        }

        const fullUri = this.opts.idBaseUrl + prefix + path;
@@ -22,8 +22,8 @@ limitations under the License.
 * @param {string} dbName The database name to test for
 * @returns {boolean} Whether the database exists
 */
-export function exists(indexedDB, dbName) {
-    return new Promise((resolve, reject) => {
+export function exists(indexedDB: IDBFactory, dbName: string): Promise<boolean> {
+    return new Promise<boolean>((resolve, reject) => {
        let exists = true;
        const req = indexedDB.open(dbName);
        req.onupgradeneeded = () => {
@@ -31,7 +31,7 @@ export function exists(indexedDB, dbName) {
            // should only fire if the DB did not exist before at any version.
            exists = false;
        };
-        req.onblocked = () => reject();
+        req.onblocked = () => reject(req.error);
        req.onsuccess = () => {
            const db = req.result;
            db.close();
@@ -45,6 +45,6 @@ export function exists(indexedDB, dbName) {
            }
            resolve(exists);
        };
-        req.onerror = ev => reject(ev.target.error);
+        req.onerror = ev => reject(req.error);
    });
 }
@@ -18,13 +18,92 @@ limitations under the License.

 /** @module interactive-auth */

-import url from "url";
 import * as utils from "./utils";
 import { logger } from './logger';
+import { MatrixClient } from "./client";
+import { defer, IDeferred } from "./utils";
+import { MatrixError } from "./http-api";

 const EMAIL_STAGE_TYPE = "m.login.email.identity";
 const MSISDN_STAGE_TYPE = "m.login.msisdn";

+interface IFlow {
+    stages: AuthType[];
+}
+
+export interface IInputs {
+    emailAddress?: string;
+    phoneCountry?: string;
+    phoneNumber?: string;
+}
+
+export interface IStageStatus {
+    emailSid?: string;
+    errcode?: string;
+    error?: string;
+}
+
+export interface IAuthData {
+    session?: string;
+    completed?: string[];
+    flows?: IFlow[];
+    params?: Record<string, Record<string, any>>;
+    errcode?: string;
+    error?: MatrixError;
+}
+
+export enum AuthType {
+    Password = "m.login.password",
+    Recaptcha = "m.login.recaptcha",
+    Terms = "m.login.terms",
+    Email = "m.login.email.identity",
+    Msisdn = "m.login.msisdn",
+    Sso = "m.login.sso",
+    SsoUnstable = "org.matrix.login.sso",
+    Dummy = "m.login.dummy",
+}
+
+export interface IAuthDict {
+    // [key: string]: any;
+    type?: string;
+    // session?: string; // TODO
+    // TODO: Remove `user` once servers support proper UIA
+    // See https://github.com/vector-im/element-web/issues/10312
+    user?: string;
+    identifier?: any;
+    password?: string;
+    response?: string;
+    // TODO: Remove `threepid_creds` once servers support proper UIA
+    // See https://github.com/vector-im/element-web/issues/10312
+    // See https://github.com/matrix-org/matrix-doc/issues/2220
+    // eslint-disable-next-line camelcase
+    threepid_creds?: any;
+    threepidCreds?: any;
+}
+
+class NoAuthFlowFoundError extends Error {
+    public name = "NoAuthFlowFoundError";
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention, camelcase
+    constructor(m: string, public readonly required_stages: string[], public readonly flows: IFlow[]) {
+        super(m);
+    }
+}
+
+interface IOpts {
+    matrixClient: MatrixClient;
+    authData?: IAuthData;
+    inputs?: IInputs;
+    sessionId?: string;
+    clientSecret?: string;
+    emailSid?: string;
+    doRequest(auth: IAuthData, background: boolean): Promise<IAuthData>;
+    stateUpdated(nextStage: AuthType, status: IStageStatus): void;
+    requestEmailToken(email: string, secret: string, attempt: number, session: string): Promise<{ sid: string }>;
+    busyChanged?(busy: boolean): void;
+    startAuthStage?(nextStage: string): Promise<void>; // LEGACY
+}
+
 /**
 * Abstracts the logic used to drive the interactive auth process.
 *
@@ -51,12 +130,12 @@ const MSISDN_STAGE_TYPE = "m.login.msisdn";
 *     called with the new auth dict to submit the request. Also passes a
 *     second deprecated arg which is a flag set to true if this request
 *     is a background request. The busyChanged callback should be used
- *     instead of the backfround flag. Should return a promise which resolves
+ *     instead of the background flag. Should return a promise which resolves
 *     to the successful response or rejects with a MatrixError.
 *
- * @param {function(bool): Promise} opts.busyChanged
+ * @param {function(boolean): Promise} opts.busyChanged
 *     called whenever the interactive auth logic becomes busy submitting
- *     information provided by the user or finsihes. After this has been
+ *     information provided by the user or finishes. After this has been
 *     called with true the UI should indicate that a request is in progress
 *     until it is called again with false.
 *
@@ -102,33 +181,41 @@ const MSISDN_STAGE_TYPE = "m.login.msisdn";
 *     attemptAuth promise.
 *
 */
-export function InteractiveAuth(opts) {
-    this._matrixClient = opts.matrixClient;
-    this._data = opts.authData || {};
-    this._requestCallback = opts.doRequest;
-    this._busyChangedCallback = opts.busyChanged;
-    // startAuthStage included for backwards compat
-    this._stateUpdatedCallback = opts.stateUpdated || opts.startAuthStage;
-    this._resolveFunc = null;
-    this._rejectFunc = null;
-    this._inputs = opts.inputs || {};
-    this._requestEmailTokenCallback = opts.requestEmailToken;
+export class InteractiveAuth {
+    private readonly matrixClient: MatrixClient;
+    private readonly inputs: IInputs;
+    private readonly clientSecret: string;
+    private readonly requestCallback: IOpts["doRequest"];
+    private readonly busyChangedCallback?: IOpts["busyChanged"];
+    private readonly stateUpdatedCallback: IOpts["stateUpdated"];
+    private readonly requestEmailTokenCallback: IOpts["requestEmailToken"];

-    if (opts.sessionId) this._data.session = opts.sessionId;
-    this._clientSecret = opts.clientSecret || this._matrixClient.generateClientSecret();
-    this._emailSid = opts.emailSid;
-    if (this._emailSid === undefined) this._emailSid = null;
-    this._requestingEmailToken = false;
-
-    this._chosenFlow = null;
-    this._currentStage = null;
+    private data: IAuthData;
+    private emailSid?: string;
+    private requestingEmailToken = false;
+    private attemptAuthDeferred: IDeferred<IAuthData> = null;
+    private chosenFlow: IFlow = null;
+    private currentStage: string = null;

    // if we are currently trying to submit an auth dict (which includes polling)
    // the promise the will resolve/reject when it completes
-    this._submitPromise = null;
-}
+    private submitPromise: Promise<void> = null;
+
+    constructor(opts: IOpts) {
+        this.matrixClient = opts.matrixClient;
+        this.data = opts.authData || {};
+        this.requestCallback = opts.doRequest;
+        this.busyChangedCallback = opts.busyChanged;
+        // startAuthStage included for backwards compat
+        this.stateUpdatedCallback = opts.stateUpdated || opts.startAuthStage;
+        this.requestEmailTokenCallback = opts.requestEmailToken;
+        this.inputs = opts.inputs || {};
+
+        if (opts.sessionId) this.data.session = opts.sessionId;
+        this.clientSecret = opts.clientSecret || this.matrixClient.generateClientSecret();
+        this.emailSid = opts.emailSid ?? null;
+    }

-InteractiveAuth.prototype = {
    /**
     * begin the authentication process.
     *
@@ -136,60 +223,57 @@ InteractiveAuth.prototype = {
     * or rejects with the error on failure. Rejects with NoAuthFlowFoundError if
     *     no suitable authentication flow can be found
     */
-    attemptAuth: function() {
+    public attemptAuth(): Promise<IAuthData> {
        // This promise will be quite long-lived and will resolve when the
        // request is authenticated and completes successfully.
-        return new Promise((resolve, reject) => {
-            this._resolveFunc = resolve;
-            this._rejectFunc = reject;
+        this.attemptAuthDeferred = defer();
+        // pluck the promise out now, as doRequest may clear before we return
+        const promise = this.attemptAuthDeferred.promise;

-            const hasFlows = this._data && this._data.flows;
-
-            // if we have no flows, try a request to acquire the flows
-            if (!hasFlows) {
-                if (this._busyChangedCallback) this._busyChangedCallback(true);
-                // use the existing sessionid, if one is present.
-                let auth = null;
-                if (this._data.session) {
-                    auth = {
-                        session: this._data.session,
-                    };
-                }
-                this._doRequest(auth).finally(() => {
-                    if (this._busyChangedCallback) this._busyChangedCallback(false);
-                });
-            } else {
-                this._startNextAuthStage();
+        // if we have no flows, try a request to acquire the flows
+        if (!this.data?.flows) {
+            this.busyChangedCallback?.(true);
+            // use the existing sessionId, if one is present.
+            let auth = null;
+            if (this.data.session) {
+                auth = {
+                    session: this.data.session,
+                };
            }
-        });
-    },
+            this.doRequest(auth).finally(() => {
+                this.busyChangedCallback?.(false);
+            });
+        } else {
+            this.startNextAuthStage();
+        }
+
+        return promise;
+    }

    /**
     * Poll to check if the auth session or current stage has been
     * completed out-of-band. If so, the attemptAuth promise will
     * be resolved.
     */
-    poll: async function() {
-        if (!this._data.session) return;
+    public async poll(): Promise<void> {
+        if (!this.data.session) return;
        // likewise don't poll if there is no auth session in progress
-        if (!this._resolveFunc) return;
+        if (!this.attemptAuthDeferred) return;
        // if we currently have a request in flight, there's no point making
        // another just to check what the status is
-        if (this._submitPromise) return;
+        if (this.submitPromise) return;

-        let authDict = {};
-        if (this._currentStage == EMAIL_STAGE_TYPE) {
+        let authDict: IAuthDict = {};
+        if (this.currentStage == EMAIL_STAGE_TYPE) {
            // The email can be validated out-of-band, but we need to provide the
            // creds so the HS can go & check it.
-            if (this._emailSid) {
-                const creds = {
-                    sid: this._emailSid,
-                    client_secret: this._clientSecret,
+            if (this.emailSid) {
+                const creds: Record<string, string> = {
+                    sid: this.emailSid,
+                    client_secret: this.clientSecret,
                };
-                if (await this._matrixClient.doesServerRequireIdServerParam()) {
-                    const idServerParsedUrl = url.parse(
-                        this._matrixClient.getIdentityServerUrl(),
-                    );
+                if (await this.matrixClient.doesServerRequireIdServerParam()) {
+                    const idServerParsedUrl = new URL(this.matrixClient.getIdentityServerUrl());
                    creds.id_server = idServerParsedUrl.host;
                }
                authDict = {
@@ -204,26 +288,26 @@ InteractiveAuth.prototype = {
        }

        this.submitAuthDict(authDict, true);
-    },
+    }

    /**
     * get the auth session ID
     *
     * @return {string} session id
     */
-    getSessionId: function() {
-        return this._data ? this._data.session : undefined;
-    },
+    public getSessionId(): string {
+        return this.data ? this.data.session : undefined;
+    }

    /**
     * get the client secret used for validation sessions
-     * with the ID server.
+     * with the identity server.
     *
     * @return {string} client secret
     */
-    getClientSecret: function() {
-        return this._clientSecret;
-    },
+    public getClientSecret(): string {
+        return this.clientSecret;
+    }

    /**
     * get the server params for a given stage
@@ -231,17 +315,13 @@ InteractiveAuth.prototype = {
     * @param {string} loginType login type for the stage
     * @return {object?} any parameters from the server for this stage
     */
-    getStageParams: function(loginType) {
-        let params = {};
-        if (this._data && this._data.params) {
-            params = this._data.params;
-        }
-        return params[loginType];
-    },
+    public getStageParams(loginType: string): Record<string, any> {
+        return this.data.params?.[loginType];
+    }

-    getChosenFlow() {
-        return this._chosenFlow;
-    },
+    public getChosenFlow(): IFlow {
+        return this.chosenFlow;
+    }

    /**
     * submit a new auth dict and fire off the request. This will either
@@ -249,38 +329,38 @@ InteractiveAuth.prototype = {
     * to be called for a new stage.
     *
     * @param {object} authData new auth dict to send to the server. Should
-     *    include a `type` propterty denoting the login type, as well as any
+     *    include a `type` property denoting the login type, as well as any
     *    other params for that stage.
-     * @param {bool} background If true, this request failing will not result
+     * @param {boolean} background If true, this request failing will not result
     *    in the attemptAuth promise being rejected. This can be set to true
     *    for requests that just poll to see if auth has been completed elsewhere.
     */
-    submitAuthDict: async function(authData, background) {
-        if (!this._resolveFunc) {
+    public async submitAuthDict(authData: IAuthDict, background = false): Promise<void> {
+        if (!this.attemptAuthDeferred) {
            throw new Error("submitAuthDict() called before attemptAuth()");
        }

-        if (!background && this._busyChangedCallback) {
-            this._busyChangedCallback(true);
+        if (!background) {
+            this.busyChangedCallback?.(true);
        }

        // if we're currently trying a request, wait for it to finish
        // as otherwise we can get multiple 200 responses which can mean
        // things like multiple logins for register requests.
-        // (but discard any expections as we only care when its done,
+        // (but discard any exceptions as we only care when its done,
        // not whether it worked or not)
-        while (this._submitPromise) {
+        while (this.submitPromise) {
            try {
-                await this._submitPromise;
+                await this.submitPromise;
            } catch (e) {
            }
        }

        // use the sessionid from the last request, if one is present.
        let auth;
-        if (this._data.session) {
+        if (this.data.session) {
            auth = {
-                session: this._data.session,
+                session: this.data.session,
            };
            utils.extend(auth, authData);
        } else {
@@ -290,15 +370,15 @@ InteractiveAuth.prototype = {
        try {
            // NB. the 'background' flag is deprecated by the busyChanged
            // callback and is here for backwards compat
-            this._submitPromise = this._doRequest(auth, background);
-            await this._submitPromise;
+            this.submitPromise = this.doRequest(auth, background);
+            await this.submitPromise;
        } finally {
-            this._submitPromise = null;
-            if (!background && this._busyChangedCallback) {
-                this._busyChangedCallback(false);
+            this.submitPromise = null;
+            if (!background) {
+                this.busyChangedCallback?.(false);
            }
        }
-    },
+    }

    /**
     * Gets the sid for the email validation session
@@ -306,9 +386,9 @@ InteractiveAuth.prototype = {
     *
     * @returns {string} The sid of the email auth session
     */
-    getEmailSid: function() {
-        return this._emailSid;
-    },
+    public getEmailSid(): string {
+        return this.emailSid;
+    }

    /**
     * Sets the sid for the email validation session
@@ -318,9 +398,9 @@ InteractiveAuth.prototype = {
     *
     * @param {string} sid The sid for the email validation session
     */
-    setEmailSid: function(sid) {
-        this._emailSid = sid;
-    },
+    public setEmailSid(sid: string): void {
+        this.emailSid = sid;
+    }

    /**
     * Fire off a request, and either resolve the promise, or call
@@ -328,33 +408,29 @@ InteractiveAuth.prototype = {
     *
     * @private
     * @param {object?} auth new auth dict, including session id
-     * @param {bool?} background If true, this request is a background poll, so it
+     * @param {boolean?} background If true, this request is a background poll, so it
     *    failing will not result in the attemptAuth promise being rejected.
     *    This can be set to true for requests that just poll to see if auth has
     *    been completed elsewhere.
     */
-    _doRequest: async function(auth, background) {
+    private async doRequest(auth: IAuthData, background = false): Promise<void> {
        try {
-            const result = await this._requestCallback(auth, background);
-            this._resolveFunc(result);
-            this._resolveFunc = null;
-            this._rejectFunc = null;
+            const result = await this.requestCallback(auth, background);
+            this.attemptAuthDeferred.resolve(result);
+            this.attemptAuthDeferred = null;
        } catch (error) {
            // sometimes UI auth errors don't come with flows
-            const errorFlows = error.data ? error.data.flows : null;
-            const haveFlows = this._data.flows || Boolean(errorFlows);
+            const errorFlows = error.data?.flows ?? null;
+            const haveFlows = this.data.flows || Boolean(errorFlows);
            if (error.httpStatus !== 401 || !error.data || !haveFlows) {
                // doesn't look like an interactive-auth failure.
                if (!background) {
-                    this._rejectFunc(error);
+                    this.attemptAuthDeferred?.reject(error);
                } else {
                    // We ignore all failures here (even non-UI auth related ones)
                    // since we don't want to suddenly fail if the internet connection
                    // had a blip whilst we were polling
-                    logger.log(
-                        "Background poll request failed doing UI auth: ignoring",
-                        error,
-                    );
+                    logger.log("Background poll request failed doing UI auth: ignoring", error);
                }
            }
            // if the error didn't come with flows, completed flows or session ID,
@@ -363,37 +439,36 @@ InteractiveAuth.prototype = {
            // has not yet been validated). This appears to be a Synapse bug, which
            // we workaround here.
            if (!error.data.flows && !error.data.completed && !error.data.session) {
-                error.data.flows = this._data.flows;
-                error.data.completed = this._data.completed;
-                error.data.session = this._data.session;
+                error.data.flows = this.data.flows;
+                error.data.completed = this.data.completed;
+                error.data.session = this.data.session;
            }
-            this._data = error.data;
+            this.data = error.data;
            try {
-                this._startNextAuthStage();
+                this.startNextAuthStage();
            } catch (e) {
-                this._rejectFunc(e);
-                this._resolveFunc = null;
-                this._rejectFunc = null;
+                this.attemptAuthDeferred.reject(e);
+                this.attemptAuthDeferred = null;
            }

            if (
-                !this._emailSid &&
-                !this._requestingEmailToken &&
-                this._chosenFlow.stages.includes('m.login.email.identity')
+                !this.emailSid &&
+                !this.requestingEmailToken &&
+                this.chosenFlow.stages.includes(AuthType.Email)
            ) {
                // If we've picked a flow with email auth, we send the email
                // now because we want the request to fail as soon as possible
                // if the email address is not valid (ie. already taken or not
                // registered, depending on what the operation is).
-                this._requestingEmailToken = true;
+                this.requestingEmailToken = true;
                try {
-                    const requestTokenResult = await this._requestEmailTokenCallback(
-                        this._inputs.emailAddress,
-                        this._clientSecret,
+                    const requestTokenResult = await this.requestEmailTokenCallback(
+                        this.inputs.emailAddress,
+                        this.clientSecret,
                        1, // TODO: Multiple send attempts?
-                        this._data.session,
+                        this.data.session,
                    );
-                    this._emailSid = requestTokenResult.sid;
+                    this.emailSid = requestTokenResult.sid;
                    // NB. promise is not resolved here - at some point, doRequest
                    // will be called again and if the user has jumped through all
                    // the hoops correctly, auth will be complete and the request
@@ -407,15 +482,14 @@ InteractiveAuth.prototype = {
                    // to do) or it could be a network failure. Either way, pass
                    // the failure up as the user can't complete auth if we can't
                    // send the email, for whatever reason.
-                    this._rejectFunc(e);
-                    this._resolveFunc = null;
-                    this._rejectFunc = null;
+                    this.attemptAuthDeferred.reject(e);
+                    this.attemptAuthDeferred = null;
                } finally {
-                    this._requestingEmailToken = false;
+                    this.requestingEmailToken = false;
                }
            }
        }
-    },
+    }

    /**
     * Pick the next stage and call the callback
@@ -423,34 +497,34 @@ InteractiveAuth.prototype = {
     * @private
     * @throws {NoAuthFlowFoundError} If no suitable authentication flow can be found
     */
-    _startNextAuthStage: function() {
-        const nextStage = this._chooseStage();
+    private startNextAuthStage(): void {
+        const nextStage = this.chooseStage();
        if (!nextStage) {
            throw new Error("No incomplete flows from the server");
        }
-        this._currentStage = nextStage;
+        this.currentStage = nextStage;

-        if (nextStage === 'm.login.dummy') {
+        if (nextStage === AuthType.Dummy) {
            this.submitAuthDict({
                type: 'm.login.dummy',
            });
            return;
        }

-        if (this._data && this._data.errcode || this._data.error) {
-            this._stateUpdatedCallback(nextStage, {
-                errcode: this._data.errcode || "",
-                error: this._data.error || "",
+        if (this.data && this.data.errcode || this.data.error) {
+            this.stateUpdatedCallback(nextStage, {
+                errcode: this.data.errcode || "",
+                error: this.data.error || "",
            });
            return;
        }

-        const stageStatus = {};
+        const stageStatus: IStageStatus = {};
        if (nextStage == EMAIL_STAGE_TYPE) {
-            stageStatus.emailSid = this._emailSid;
+            stageStatus.emailSid = this.emailSid;
        }
-        this._stateUpdatedCallback(nextStage, stageStatus);
-    },
+        this.stateUpdatedCallback(nextStage, stageStatus);
+    }

    /**
     * Pick the next auth stage
@@ -459,15 +533,15 @@ InteractiveAuth.prototype = {
     * @return {string?} login type
     * @throws {NoAuthFlowFoundError} If no suitable authentication flow can be found
     */
-    _chooseStage: function() {
-        if (this._chosenFlow === null) {
-            this._chosenFlow = this._chooseFlow();
+    private chooseStage(): AuthType {
+        if (this.chosenFlow === null) {
+            this.chosenFlow = this.chooseFlow();
        }
-        logger.log("Active flow => %s", JSON.stringify(this._chosenFlow));
-        const nextStage = this._firstUncompletedStage(this._chosenFlow);
+        logger.log("Active flow => %s", JSON.stringify(this.chosenFlow));
+        const nextStage = this.firstUncompletedStage(this.chosenFlow);
        logger.log("Next stage: %s", nextStage);
        return nextStage;
-    },
+    }

    /**
     * Pick one of the flows from the returned list
@@ -475,7 +549,7 @@ InteractiveAuth.prototype = {
     * be returned, otherwise, null will be returned.
     *
     * Only flows using all given inputs are chosen because it
-     * is likley to be surprising if the user provides a
+     * is likely to be surprising if the user provides a
     * credential and it is not used. For example, for registration,
     * this could result in the email not being used which would leave
     * the account with no means to reset a password.
@@ -484,14 +558,14 @@ InteractiveAuth.prototype = {
     * @return {object} flow
     * @throws {NoAuthFlowFoundError} If no suitable authentication flow can be found
     */
-    _chooseFlow: function() {
-        const flows = this._data.flows || [];
+    private chooseFlow(): IFlow {
+        const flows = this.data.flows || [];

        // we've been given an email or we've already done an email part
-        const haveEmail = Boolean(this._inputs.emailAddress) || Boolean(this._emailSid);
+        const haveEmail = Boolean(this.inputs.emailAddress) || Boolean(this.emailSid);
        const haveMsisdn = (
-            Boolean(this._inputs.phoneCountry) &&
-            Boolean(this._inputs.phoneNumber)
+            Boolean(this.inputs.phoneCountry) &&
+            Boolean(this.inputs.phoneNumber)
        );

        for (const flow of flows) {
@@ -509,16 +583,14 @@ InteractiveAuth.prototype = {
                return flow;
            }
        }
+
+        const requiredStages: string[] = [];
+        if (haveEmail) requiredStages.push(EMAIL_STAGE_TYPE);
+        if (haveMsisdn) requiredStages.push(MSISDN_STAGE_TYPE);
        // Throw an error with a fairly generic description, but with more
        // information such that the app can give a better one if so desired.
-        const err = new Error("No appropriate authentication flow found");
-        err.name = 'NoAuthFlowFoundError';
-        err.required_stages = [];
-        if (haveEmail) err.required_stages.push(EMAIL_STAGE_TYPE);
-        if (haveMsisdn) err.required_stages.push(MSISDN_STAGE_TYPE);
-        err.available_flows = flows;
-        throw err;
-    },
+        throw new NoAuthFlowFoundError("No appropriate authentication flow found", requiredStages, flows);
+    }

    /**
     * Get the first uncompleted stage in the given flow
@@ -527,14 +599,13 @@ InteractiveAuth.prototype = {
     * @param {object} flow
     * @return {string} login type
     */
-    _firstUncompletedStage: function(flow) {
-        const completed = (this._data || {}).completed || [];
+    private firstUncompletedStage(flow: IFlow): AuthType {
+        const completed = this.data.completed || [];
        for (let i = 0; i < flow.stages.length; ++i) {
            const stageType = flow.stages[i];
            if (completed.indexOf(stageType) === -1) {
                return stageType;
            }
        }
-    },
-};
-
+    }
+}
@@ -60,9 +60,9 @@ 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);

-interface PrefixedLogger extends Logger {
+export interface PrefixedLogger extends Logger {
    withPrefix?: (prefix: string) => PrefixedLogger;
    prefix?: string;
 }
@@ -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
@@ -154,7 +152,7 @@ export function createClient(opts: ICreateClientOpts | string) {
    }
    opts.request = opts.request || requestInstance;
    opts.store = opts.store || new MemoryStore({
-      localStorage: global.localStorage,
+        localStorage: global.localStorage,
    });
    opts.scheduler = opts.scheduler || new MatrixScheduler();
    opts.cryptoStore = opts.cryptoStore || cryptoStoreFactory();
@@ -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
    }

    /**
@@ -70,33 +83,136 @@ export class MSC3089Branch {
     * @param {string} name The new name for this file.
     * @returns {Promise<void>} Resolves when complete.
     */
-    public setName(name: string): Promise<void> {
-        return this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
+    public async setName(name: string): Promise<void> {
+        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
            ...this.indexEvent.getContent(),
            name: name,
        }, 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.
     */
    public async getFileInfo(): Promise<{ info: IEncryptedFile, httpUrl: string }> {
-        const room = this.client.getRoom(this.roomId);
-        if (!room) throw new Error("Unknown room");
+        const event = await this.getFileEvent();

-        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);
-        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 });
-
-        const file = event.getContent()['file'];
+        const file = event.getOriginalContent()['file'];
        const httpUrl = this.client.mxcUrlToHttp(file['url']);

        return { info: file, httpUrl: httpUrl };
    }
+
+    /**
+     * Gets the event the file points to.
+     * @returns {Promise<MatrixEvent>} Resolves to the file's event.
+     */
+    public async getFileEvent(): Promise<MatrixEvent> {
+        const room = this.client.getRoom(this.roomId);
+        if (!room) throw new Error("Unknown room");
+
+        const event = room.getUnfilteredTimelineSet().findEventById(this.id);
+        if (!event) throw new Error("Failed to find event");
+
+        // 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;
+    }
 }
@@ -18,7 +18,7 @@ import { MatrixClient } from "../client";
 import { EventType, IEncryptedFile, MsgType, UNSTABLE_MSC3089_BRANCH, UNSTABLE_MSC3089_LEAF } from "../@types/event";
 import { Room } from "./room";
 import { logger } from "../logger";
-import { MatrixEvent } from "./event";
+import { IContent, MatrixEvent } from "./event";
 import {
    averageBetweenStrings,
    DEFAULT_ALPHABET,
@@ -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
@@ -111,8 +112,8 @@ export class MSC3089TreeSpace {
     * @param {string} name The new name for the space.
     * @returns {Promise<void>} Resolves when complete.
     */
-    public setName(name: string): Promise<void> {
-        return this.client.sendStateEvent(this.roomId, EventType.RoomName, { name }, "");
+    public async setName(name: string): Promise<void> {
+        await this.client.sendStateEvent(this.roomId, EventType.RoomName, { name }, "");
    }

    /**
@@ -190,7 +191,29 @@ export class MSC3089TreeSpace {
        }
        pls['users'] = users;

-        return this.client.sendStateEvent(this.roomId, EventType.RoomPowerLevels, pls, "");
+        await this.client.sendStateEvent(this.roomId, EventType.RoomPowerLevels, pls, "");
+    }
+
+    /**
+     * Gets the current permissions of a user. Note that any users missing explicit permissions (or not
+     * in the space) will be considered Viewers. Appropriate membership checks need to be performed
+     * elsewhere.
+     * @param {string} userId The user ID to check permissions of.
+     * @returns {TreePermissions} The permissions for the user, defaulting to Viewer.
+     */
+    public getPermissions(userId: string): TreePermissions {
+        const currentPls = this.room.currentState.getStateEvents(EventType.RoomPowerLevels, "");
+        if (Array.isArray(currentPls)) throw new Error("Unexpected return type for power levels");
+
+        const pls = currentPls.getContent() || {};
+        const viewLevel = pls['users_default'] || 0;
+        const editLevel = pls['events_default'] || 50;
+        const adminLevel = pls['events']?.[EventType.RoomPowerLevels] || 100;
+
+        const userLevel = pls['users']?.[userId] || viewLevel;
+        if (userLevel >= adminLevel) return TreePermissions.Owner;
+        if (userLevel >= editLevel) return TreePermissions.Editor;
+        return TreePermissions.Viewer;
    }

    /**
@@ -429,23 +452,39 @@ export class MSC3089TreeSpace {
     * @param {string} name The name of the file.
     * @param {ArrayBuffer} encryptedContents The encrypted contents.
     * @param {Partial<IEncryptedFile>} info The encrypted file information.
-     * @returns {Promise<void>} Resolves when uploaded.
+     * @param {IContent} additionalContent Optional event content fields to include in the message.
+     * @returns {Promise<ISendEventResponse>} Resolves to the file event's sent response.
     */
    public async createFile(
        name: string,
-        encryptedContents: ArrayBuffer, info: Partial<IEncryptedFile>,
-    ): Promise<void> {
+        encryptedContents: ArrayBuffer,
+        info: Partial<IEncryptedFile>,
+        additionalContent?: IContent,
+    ): 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, {
+        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]: {},
        });

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

    /**
@@ -462,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;
    }

    /**
@@ -470,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);
@@ -50,13 +50,15 @@ export class EventTimeline {
     * @param {boolean} toStartOfTimeline  if true the event's forwardLooking flag is set false
     */
    static setEventMetadata(event: MatrixEvent, stateContext: RoomState, toStartOfTimeline: boolean): void {
-        // We always check if the event doesn't already have the property. We do
-        // this to avoid overriding non-sentinel members by sentinel ones when
-        // adding the event to a filtered timeline
-        if (!event.sender) {
+        // When we try to generate a sentinel member before we have that member
+        // in the members object, we still generate a sentinel but it doesn't
+        // have a membership event, so test to see if events.member is set. We
+        // check this to avoid overriding non-sentinel members by sentinel ones
+        // when adding the event to a filtered timeline
+        if (!event.sender?.events?.member) {
            event.sender = stateContext.getSentinelMember(event.getSender());
        }
-        if (!event.target && event.getType() === EventType.RoomMember) {
+        if (!event.target?.events?.member && event.getType() === EventType.RoomMember) {
            event.target = stateContext.getSentinelMember(event.getStateKey());
        }

@@ -345,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) {
@@ -24,10 +24,18 @@ import { EventEmitter } from 'events';

 import { logger } from '../logger';
 import { VerificationRequest } from "../crypto/verification/request/VerificationRequest";
-import { EventType, MsgType, RelationType } from "../@types/event";
+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, ThreadEvent } from "./thread";
+import { IActionsObject } from '../pushprocessor';
+import { ReEmitter } from '../ReEmitter';

 /**
 * Enum for event statuses.
@@ -148,11 +156,11 @@ export interface IDecryptOptions {
 }

 export class MatrixEvent extends EventEmitter {
-    private pushActions: object = null;
+    private pushActions: IActionsObject = null;
    private _replacingEvent: MatrixEvent = null;
    private _localRedactionEvent: MatrixEvent = null;
    private _isCancelled = false;
-    private clearEvent: Partial<IClearEvent> = {};
+    private clearEvent?: IClearEvent;

    /* curve25519 key which we believe belongs to the sender of the event. See
     * getSenderKey()
@@ -190,6 +198,12 @@ export class MatrixEvent extends EventEmitter {
     */
    private txnId: string = null;

+    /**
+     * @experimental
+     * A reference to the thread this event belongs to
+     */
+    private thread: Thread = null;
+
    /* Set an approximate timestamp for the event relative the local clock.
     * This will inherently be approximate because it doesn't take into account
     * the time between the server putting the 'age' field on the event as it sent
@@ -211,6 +225,8 @@ export class MatrixEvent extends EventEmitter {
     */
    public verificationRequest = null;

+    private readonly reEmitter: ReEmitter;
+
    /**
     * Construct a Matrix Event object
     * @constructor
@@ -260,6 +276,37 @@ export class MatrixEvent extends EventEmitter {

        this.txnId = event.txn_id || null;
        this.localTimestamp = Date.now() - this.getAge();
+        this.reEmitter = new ReEmitter(this);
+    }
+
+    /**
+     * Gets the event as though it would appear unencrypted. If the event is already not
+     * encrypted, it is simply returned as-is.
+     * @returns {IEvent} The event in wire format.
+     */
+    public getEffectiveEvent(): 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;
    }

    /**
@@ -285,7 +332,10 @@ export class MatrixEvent extends EventEmitter {
     * @return {string} The event type, e.g. <code>m.room.message</code>
     */
    public getType(): EventType | string {
-        return this.clearEvent.type || this.event.type;
+        if (this.clearEvent) {
+            return this.clearEvent.type;
+        }
+        return this.event.type;
    }

    /**
@@ -334,7 +384,10 @@ export class MatrixEvent extends EventEmitter {
        if (this._localRedactionEvent) {
            return {} as T;
        }
-        return (this.clearEvent.content || this.event.content || {}) as T;
+        if (this.clearEvent) {
+            return (this.clearEvent.content || {}) as T;
+        }
+        return (this.event.content || {}) as T;
    }

    /**
@@ -364,6 +417,42 @@ export class MatrixEvent extends EventEmitter {
        return this.event.content || {};
    }

+    /**
+     * @experimental
+     * Get the event ID of the replied event
+     */
+    public get replyEventId(): string {
+        const relations = this.getWireContent()["m.relates_to"];
+        return relations?.["m.in_reply_to"]?.["event_id"];
+    }
+
+    /**
+     * @experimental
+     * Determines whether a reply should be rendered in a thread
+     * or in the main room timeline
+     */
+    public get replyInThread(): boolean {
+        /**
+         * UNSTABLE_ELEMENT_REPLY_IN_THREAD can live either
+         * at the m.relates_to and m.in_reply_to level
+         * This will likely change once we settle on a
+         * way to achieve threads
+         * TODO: Clean this up once we have a clear way forward
+         */
+
+        const relatesTo = this.getWireContent()?.["m.relates_to"];
+        const replyTo = relatesTo?.["m.in_reply_to"];
+
+        return relatesTo?.[UNSTABLE_ELEMENT_REPLY_IN_THREAD.name]
+            || (this.replyEventId && replyTo[UNSTABLE_ELEMENT_REPLY_IN_THREAD.name])
+            || this.thread instanceof Thread;
+    }
+
+    public get parentEventId(): string {
+        return this.replyEventId
+            || this.getWireContent()["m.relates_to"]?.event_id;
+    }
+
    /**
     * Get the previous event content JSON. This will only return something for
     * state events which exist in the timeline.
@@ -486,7 +575,7 @@ export class MatrixEvent extends EventEmitter {
    }

    public shouldAttemptDecryption() {
-        return this.isEncrypted() && !this.isBeingDecrypted() && this.getClearContent() === null;
+        return this.isEncrypted() && !this.isBeingDecrypted() && !this.clearEvent;
    }

    /**
@@ -518,10 +607,7 @@ export class MatrixEvent extends EventEmitter {
            throw new Error("Attempt to decrypt event which isn't encrypted");
        }

-        if (
-            this.clearEvent && this.clearEvent.content &&
-            this.clearEvent.content.msgtype !== "m.bad.encrypted"
-        ) {
+        if (this.clearEvent && !this.isDecryptionFailure()) {
            // we may want to just ignore this? let's start with rejecting it.
            throw new Error(
                "Attempt to decrypt event which has already been decrypted",
@@ -729,8 +815,7 @@ export class MatrixEvent extends EventEmitter {
     * @returns {Object} The cleartext (decrypted) content for the event
     */
    public getClearContent(): IContent | null {
-        const ev = this.clearEvent;
-        return ev && ev.content ? ev.content : null;
+        return this.clearEvent ? this.clearEvent.content : null;
    }

    /**
@@ -921,8 +1006,8 @@ export class MatrixEvent extends EventEmitter {
    public getRedactionEvent(): object | null {
        if (!this.isRedacted()) return null;

-        if (this.clearEvent.unsigned) {
-            return this.clearEvent.unsigned.redacted_because;
+        if (this.clearEvent?.unsigned) {
+            return this.clearEvent?.unsigned.redacted_because;
        } else if (this.event.unsigned.redacted_because) {
            return this.event.unsigned.redacted_because;
        } else {
@@ -935,7 +1020,7 @@ export class MatrixEvent extends EventEmitter {
     *
     * @return {?Object} push actions
     */
-    public getPushActions(): object | null {
+    public getPushActions(): IActionsObject | null {
        return this.pushActions;
    }

@@ -944,7 +1029,7 @@ export class MatrixEvent extends EventEmitter {
     *
     * @param {Object} pushActions push actions
     */
-    public setPushActions(pushActions: object): void {
+    public setPushActions(pushActions: IActionsObject): void {
        this.pushActions = pushActions;
    }

@@ -1222,28 +1307,20 @@ export class MatrixEvent extends EventEmitter {
    }

    /**
-     * Summarise the event as JSON for debugging. If encrypted, include both the
-     * decrypted and encrypted view of the event. This is named `toJSON` for use
-     * with `JSON.stringify` which checks objects for functions named `toJSON`
-     * and will call them to customise the output if they are defined.
+     * Summarise the event as JSON. This is currently used by React SDK's view
+     * event source feature and Seshat's event indexing, so take care when
+     * adjusting the output here.
+     *
+     * If encrypted, include both the decrypted and encrypted view of the event.
+     *
+     * This is named `toJSON` for use with `JSON.stringify` which checks objects
+     * for functions named `toJSON` and will call them to customise the output
+     * if they are defined.
     *
     * @return {Object}
     */
    public toJSON(): object {
-        const event: any = {
-            type: this.getType(),
-            sender: this.getSender(),
-            content: this.getContent(),
-            event_id: this.getId(),
-            origin_server_ts: this.getTs(),
-            unsigned: this.getUnsigned(),
-            room_id: this.getRoomId(),
-        };
-
-        // if this is a redaction then attach the redacts key
-        if (this.isRedaction()) {
-            event.redacts = this.event.redacts;
-        }
+        const event = this.getEffectiveEvent();

        if (!this.isEncrypted()) {
            return event;
@@ -1266,6 +1343,21 @@ export class MatrixEvent extends EventEmitter {
    public getTxnId(): string | undefined {
        return this.txnId;
    }
+
+    /**
+     * @experimental
+     */
+    public setThread(thread: Thread): void {
+        this.thread = thread;
+        this.reEmitter.reEmit(thread, [ThreadEvent.Ready, ThreadEvent.Update]);
+    }
+
+    /**
+     * @experimental
+     */
+    public getThread(): Thread {
+        return this.thread;
+    }
 }

 /* REDACT_KEEP_KEYS gives the keys we keep when an event is redacted
@@ -17,6 +17,7 @@ limitations under the License.

 /**
 * @module models/group
+ * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
 */

 import * as utils from "../utils";
@@ -34,6 +35,7 @@ import { EventEmitter } from "events";
 * @prop {Object} inviter Infomation about the user who invited the logged in user
 *       to the group, if myMembership is 'invite'.
 * @prop {string} inviter.userId The user ID of the inviter
+ * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
 */
 export function Group(groupId) {
    this.groupId = groupId;
@@ -76,6 +78,7 @@ Group.prototype.setInviter = function(inviter) {
 * This means the 'name' and 'avatarUrl' properties.
 * @event module:client~MatrixClient#"Group.profile"
 * @param {Group} group The group whose profile was updated.
+ * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
 * @example
 * matrixClient.on("Group.profile", function(group){
 *   var name = group.name;
@@ -87,6 +90,7 @@ Group.prototype.setInviter = function(inviter) {
 * the group is updated.
 * @event module:client~MatrixClient#"Group.myMembership"
 * @param {Group} group The group in which the user's membership changed
+ * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
 * @example
 * matrixClient.on("Group.myMembership", function(group){
 *   var myMembership = group.myMembership;
@@ -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") {
@@ -131,7 +131,11 @@ export class RoomMember extends EventEmitter {
            this.disambiguate,
        );

-        this.rawDisplayName = event.getDirectionalContent().displayname || this.userId;
+        this.rawDisplayName = event.getDirectionalContent().displayname;
+        if (!this.rawDisplayName || !utils.removeHiddenChars(this.rawDisplayName)) {
+            this.rawDisplayName = this.userId;
+        }
+
        if (oldMembership !== this.membership) {
            this.updateModifiedTime();
            this.emit("RoomMember.membership", event, this, oldMembership);
@@ -318,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,6 +26,7 @@ import * as utils from "../utils";
 import { EventType } from "../@types/event";
 import { MatrixEvent } from "./event";
 import { MatrixClient } from "../client";
+import { GuestAccess, HistoryVisibility, IJoinRuleEventContent, JoinRule } from "../@types/partials";

 // possible statuses for out-of-band member loading
 enum OobStatus {
@@ -204,9 +205,9 @@ export class RoomState extends EventEmitter {
     * @return {MatrixEvent[]|MatrixEvent} A list of events if state_key was
     * <code>undefined</code>, else a single event (or null if no match found).
     */
-    public getStateEvents(eventType: string): MatrixEvent[];
-    public getStateEvents(eventType: string, stateKey: string): MatrixEvent;
-    public getStateEvents(eventType: string, stateKey?: string) {
+    public getStateEvents(eventType: EventType | string): MatrixEvent[];
+    public getStateEvents(eventType: EventType | string, stateKey: string): MatrixEvent;
+    public getStateEvents(eventType: EventType | string, stateKey?: string) {
        if (!this.events.has(eventType)) {
            // no match
            return stateKey === undefined ? [] : null;
@@ -577,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 = {};
@@ -728,10 +729,30 @@ export class RoomState extends EventEmitter {
     * Returns the join rule based on the m.room.join_rule state event, defaulting to `invite`.
     * @returns {string} the join_rule applied to this room
     */
-    public getJoinRule(): string {
+    public getJoinRule(): JoinRule {
        const joinRuleEvent = this.getStateEvents(EventType.RoomJoinRules, "");
-        const joinRuleContent = joinRuleEvent ? joinRuleEvent.getContent() : {};
-        return joinRuleContent["join_rule"] || "invite";
+        const joinRuleContent = joinRuleEvent?.getContent<IJoinRuleEventContent>() ?? {};
+        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 {
@@ -20,21 +20,22 @@ 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";
 import { normalize } from "../utils";
-import { EventStatus, MatrixEvent } from "./event";
+import { EventStatus, IEvent, MatrixEvent } from "./event";
 import { RoomMember } from "./room-member";
 import { IRoomSummary, RoomSummary } from "./room-summary";
 import { logger } from '../logger';
 import { ReEmitter } from '../ReEmitter';
-import { EventType, RoomCreateTypeField, RoomType } from "../@types/event";
-import { IRoomVersionsCapability, MatrixClient, RoomVersionStability } from "../client";
-import { ResizeMethod } from "../@types/partials";
+import { EventType, RoomCreateTypeField, RoomType, UNSTABLE_ELEMENT_FUNCTIONAL_USERS } from "../@types/event";
+import { IRoomVersionsCapability, MatrixClient, PendingEventOrdering, RoomVersionStability } from "../client";
+import { GuestAccess, HistoryVisibility, JoinRule, ResizeMethod } from "../@types/partials";
 import { Filter } from "../filter";
 import { RoomState } from "./room-state";
+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
@@ -64,7 +65,7 @@ function synthesizeReceipt(userId: string, event: MatrixEvent, receiptType: stri

 interface IOpts {
    storageToken?: string;
-    pendingEventOrdering?: "chronological" | "detached";
+    pendingEventOrdering?: PendingEventOrdering;
    timelineSupport?: boolean;
    unstableClientRelationAggregation?: boolean;
    lazyLoadMembers?: boolean;
@@ -145,6 +146,11 @@ export class Room extends EventEmitter {
    public oldState: RoomState;
    public currentState: RoomState;

+    /**
+     * @experimental
+     */
+    public threads = new Set<Thread>();
+
    /**
     * Construct a new Room.
     *
@@ -218,7 +224,7 @@ export class Room extends EventEmitter {
        this.setMaxListeners(100);
        this.reEmitter = new ReEmitter(this);

-        opts.pendingEventOrdering = opts.pendingEventOrdering || "chronological";
+        opts.pendingEventOrdering = opts.pendingEventOrdering || PendingEventOrdering.Chronological;
        if (["chronological", "detached"].indexOf(opts.pendingEventOrdering) === -1) {
            throw new Error(
                "opts.pendingEventOrdering MUST be either 'chronological' or " +
@@ -649,7 +655,7 @@ export class Room extends EventEmitter {
        }
    }

-    private async loadMembersFromServer(): Promise<object[]> {
+    private async loadMembersFromServer(): Promise<IEvent[]> {
        const lastSyncToken = this.client.store.getSyncToken();
        const queryString = utils.encodeParams({
            not_membership: "leave",
@@ -665,8 +671,7 @@ export class Room extends EventEmitter {
    private async loadMembers(): Promise<{ memberEvents: MatrixEvent[], fromServer: boolean }> {
        // were the members loaded from the server?
        let fromServer = false;
-        let rawMembersEvents =
-            await this.client.store.getOutOfBandMembers(this.roomId);
+        let rawMembersEvents = await this.client.store.getOutOfBandMembers(this.roomId);
        if (rawMembersEvents === null) {
            fromServer = true;
            rawMembersEvents = await this.loadMembersFromServer();
@@ -713,7 +718,7 @@ export class Room extends EventEmitter {
            if (fromServer) {
                const oobMembers = this.currentState.getMembers()
                    .filter((m) => m.isOutOfBand())
-                    .map((m) => m.events.member.event);
+                    .map((m) => m.events.member.event as IEvent);
                logger.log(`LL: telling store to write ${oobMembers.length}`
                    + ` members for room ${this.roomId}`);
                const store = this.client.store;
@@ -858,13 +863,26 @@ export class Room extends EventEmitter {
    }

    /**
-     * Get an event which is stored in our unfiltered timeline set
+     * Get an event which is stored in our unfiltered timeline set or in a thread
     *
     * @param {string} eventId  event ID to look for
     * @return {?module:models/event.MatrixEvent} the given event, or undefined if unknown
     */
    public findEventById(eventId: string): MatrixEvent | undefined {
-        return this.getUnfilteredTimelineSet().findEventById(eventId);
+        let event = this.getUnfilteredTimelineSet().findEventById(eventId);
+
+        if (event) {
+            return event;
+        } else {
+            const threads = this.getThreads();
+            for (let i = 0; i < threads.length; i++) {
+                const thread = threads[i];
+                event = thread.findEventById(eventId);
+                if (event) {
+                    return event;
+                }
+            }
+        }
    }

    /**
@@ -1050,6 +1068,55 @@ export class Room extends EventEmitter {
        );
    }

+    /**
+     * @experimental
+     */
+    public addThread(thread: Thread): Set<Thread> {
+        this.threads.add(thread);
+        if (!thread.ready) {
+            thread.once(ThreadEvent.Ready, this.dedupeThreads);
+            this.emit(ThreadEvent.Update, thread);
+            this.reEmitter.reEmit(thread, [ThreadEvent.Update, ThreadEvent.Ready]);
+        }
+        return this.threads;
+    }
+
+    /**
+     * @experimental
+     */
+    public getThread(eventId: string): Thread {
+        return this.getThreads().find(thread => {
+            return thread.id === eventId;
+        });
+    }
+
+    /**
+     * @experimental
+     */
+    public getThreads(): Thread[] {
+        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.
@@ -1226,6 +1293,23 @@ export class Room extends EventEmitter {
        }
    }

+    /**
+     * Add an event to a thread's timeline. Will fire "Thread.update"
+     * @experimental
+     */
+    public addThreadedEvent(event: MatrixEvent): void {
+        let thread = this.findEventById(event.parentEventId)?.getThread();
+        if (thread) {
+            thread.addEvent(event);
+        } else {
+            thread = new Thread([event], this, this.client);
+        }
+
+        if (!this.threads.has(thread)) {
+            this.addThread(thread);
+        }
+    }
+
    /**
     * Add an event to the end of this room's live timelines. Will fire
     * "Room.timeline".
@@ -1236,12 +1320,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);

@@ -1322,6 +1406,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.replyInThread) {
+            return;
+        }
+
        if (event.status !== EventStatus.SENDING && event.status !== EventStatus.NOT_SENT) {
            throw new Error("addPendingEvent called on an event with status " +
                event.status);
@@ -1494,6 +1585,14 @@ export class Room extends EventEmitter {
            oldEventId, oldStatus);
    }

+    public findThreadByEventId(eventId: string): Thread {
+        for (const thread of this.threads) {
+            if (thread.has(eventId)) {
+                return thread;
+            }
+        }
+    }
+
    /**
     * Update the status / event id on a pending event, to reflect its transmission
     * progress.
@@ -1607,7 +1706,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'");
@@ -1974,10 +2073,26 @@ export class Room extends EventEmitter {
     * Returns the join rule based on the m.room.join_rule state event, defaulting to `invite`.
     * @returns {string} the join_rule applied to this room
     */
-    public getJoinRule(): string {
+    public getJoinRule(): JoinRule {
        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.
@@ -2037,24 +2152,45 @@ export class Room extends EventEmitter {
        const joinedMemberCount = this.currentState.getJoinedMemberCount();
        const invitedMemberCount = this.currentState.getInvitedMemberCount();
        // -1 because these numbers include the syncing user
-        const inviteJoinCount = joinedMemberCount + invitedMemberCount - 1;
+        let inviteJoinCount = joinedMemberCount + invitedMemberCount - 1;
+
+        // get service members (e.g. helper bots) for exclusion
+        let excludedUserIds: string[] = [];
+        const mFunctionalMembers = this.currentState.getStateEvents(UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, "");
+        if (Array.isArray(mFunctionalMembers?.getContent().service_members)) {
+            excludedUserIds = mFunctionalMembers.getContent().service_members;
+        }

        // get members that are NOT ourselves and are actually in the room.
        let otherNames = null;
        if (this.summaryHeroes) {
            // if we have a summary, the member state events
            // should be in the room state
-            otherNames = this.summaryHeroes.map((userId) => {
+            otherNames = [];
+            this.summaryHeroes.forEach((userId) => {
+                // filter service members
+                if (excludedUserIds.includes(userId)) {
+                    inviteJoinCount--;
+                    return;
+                }
                const member = this.getMember(userId);
-                return member ? member.name : userId;
+                otherNames.push(member ? member.name : userId);
            });
        } else {
            let otherMembers = this.currentState.getMembers().filter((m) => {
                return m.userId !== userId &&
                    (m.membership === "invite" || m.membership === "join");
            });
+            otherMembers = otherMembers.filter(({ userId }) => {
+                // filter service members
+                if (excludedUserIds.includes(userId)) {
+                    inviteJoinCount--;
+                    return false;
+                }
+                return true;
+            });
            // make sure members have stable order
-            otherMembers.sort((a, b) => a.userId.localeCompare(b.userId));
+            otherMembers.sort((a, b) => utils.compare(a.userId, b.userId));
            // only 5 first members, immitate summaryHeroes
            otherMembers = otherMembers.slice(0, 5);
            otherNames = otherMembers.map((m) => m.name);
@@ -2065,7 +2201,7 @@ export class Room extends EventEmitter {
        }

        const myMembership = this.getMyMembership();
-        // if I have created a room and invited people throuh
+        // if I have created a room and invited people through
        // 3rd party invites
        if (myMembership == 'join') {
            const thirdPartyInvites =
@@ -1,60 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2019 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.
-*/
-
-/**
- * @module models/search-result
- */
-
-import { EventContext } from "./event-context";
-
-/**
- * Construct a new SearchResult
- *
- * @param {number} rank   where this SearchResult ranks in the results
- * @param {event-context.EventContext} eventContext  the matching event and its
- *    context
- *
- * @constructor
- */
-export function SearchResult(rank, eventContext) {
-    this.rank = rank;
-    this.context = eventContext;
-}
-
-/**
- * Create a SearchResponse from the response to /search
- * @static
- * @param {Object} jsonObj
- * @param {function} eventMapper
- * @return {SearchResult}
- */
-
-SearchResult.fromJson = function(jsonObj, eventMapper) {
-    const jsonContext = jsonObj.context || {};
-    const events_before = jsonContext.events_before || [];
-    const events_after = jsonContext.events_after || [];
-
-    const context = new EventContext(eventMapper(jsonObj.result));
-
-    context.setPaginateToken(jsonContext.start, true);
-    context.addEvents(events_before.map(eventMapper), true);
-    context.addEvents(events_after.map(eventMapper), false);
-    context.setPaginateToken(jsonContext.end, false);
-
-    return new SearchResult(jsonObj.rank, context);
-};
-
@@ -0,0 +1,59 @@
+/*
+Copyright 2015 - 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.
+*/
+
+/**
+ * @module models/search-result
+ */
+
+import { EventContext } from "./event-context";
+import { EventMapper } from "../event-mapper";
+import { IResultContext, ISearchResult } from "../@types/search";
+
+export class SearchResult {
+    /**
+     * Create a SearchResponse from the response to /search
+     * @static
+     * @param {Object} jsonObj
+     * @param {function} eventMapper
+     * @return {SearchResult}
+     */
+
+    public static fromJson(jsonObj: ISearchResult, eventMapper: EventMapper): SearchResult {
+        const jsonContext = jsonObj.context || {} as IResultContext;
+        const eventsBefore = jsonContext.events_before || [];
+        const eventsAfter = jsonContext.events_after || [];
+
+        const context = new EventContext(eventMapper(jsonObj.result));
+
+        context.setPaginateToken(jsonContext.start, true);
+        context.addEvents(eventsBefore.map(eventMapper), true);
+        context.addEvents(eventsAfter.map(eventMapper), false);
+        context.setPaginateToken(jsonContext.end, false);
+
+        return new SearchResult(jsonObj.rank, context);
+    }
+
+    /**
+     * Construct a new SearchResult
+     *
+     * @param {number} rank   where this SearchResult ranks in the results
+     * @param {event-context.EventContext} context  the matching event and its
+     *    context
+     *
+     * @constructor
+     */
+    constructor(public readonly rank: number, public readonly context: EventContext) {}
+}
@@ -0,0 +1,247 @@
+/*
+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 { 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 {
+    Ready = "Thread.ready",
+    Update = "Thread.update"
+}
+
+interface ISerialisedThread {
+    id: string;
+    tails: string[];
+}
+
+/**
+ * @experimental
+ */
+export class Thread extends EventEmitter {
+    /**
+     * A reference to the event ID at the top of the thread
+     */
+    private root: string;
+    /**
+     * A reference to all the events ID at the bottom of the threads
+     */
+    public readonly tail = new Set<string>();
+    public readonly timelineSet: EventTimelineSet;
+
+    constructor(
+        events: MatrixEvent[] = [],
+        public readonly room: Room,
+        public readonly client: MatrixClient,
+    ) {
+        super();
+        this.timelineSet = new EventTimelineSet(room, {
+            unstableClientRelationAggregation: true,
+            timelineSupport: true,
+        });
+        events.forEach(event => this.addEvent(event));
+    }
+
+    /**
+     * Add an event to the thread and updates
+     * the tail/root references if needed
+     * Will fire "Thread.update"
+     * @param event The event to add
+     */
+    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);
+        }
+        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.addEventToTimeline(
+            event,
+            this.timelineSet.getLiveTimeline(),
+            toStartOfTimeline,
+            false,
+            roomState,
+        );
+
+        if (this.ready) {
+            this.client.decryptEventIfNeeded(event, {});
+        }
+        this.emit(ThreadEvent.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, true);
+            if (mxEvent.replyEventId) {
+                await this.fetchReplyChain();
+            } else {
+                await this.decryptEvents();
+                this.emit(ThreadEvent.Ready, this);
+            }
+        }
+    }
+
+    private async decryptEvents(): Promise<void> {
+        await Promise.allSettled(
+            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);
+    }
+
+    /**
+     * Determines thread's ready status
+     */
+    public get ready(): boolean {
+        return this.rootEvent.replyEventId === undefined;
+    }
+
+    /**
+     * The thread ID, which is the same as the root event ID
+     */
+    public get id(): string {
+        return this.root;
+    }
+
+    /**
+     * The thread root event
+     */
+    public get rootEvent(): MatrixEvent {
+        return this.findEventById(this.root);
+    }
+
+    public get roomId(): string {
+        return this.rootEvent.getRoomId();
+    }
+
+    /**
+     * The number of messages in the thread
+     */
+    public get length(): number {
+        return this.events.length;
+    }
+
+    /**
+     * A set of mxid participating to the thread
+     */
+    public get participants(): Set<string> {
+        const participants = new Set<string>();
+        this.events.forEach(event => {
+            participants.add(event.getSender());
+        });
+        return participants;
+    }
+
+    /**
+     * A getter for the last event added to the thread
+     */
+    public get replyToEvent(): MatrixEvent {
+        const events = this.events;
+        return events[events.length -1];
+    }
+
+    public get events(): MatrixEvent[] {
+        return this.timelineSet.getLiveTimeline().getEvents();
+    }
+
+    public merge(thread: Thread): void {
+        thread.events.forEach(event => {
+            this.addEvent(event);
+        });
+        this.events.forEach(event => event.setThread(this));
+    }
+
+    public has(eventId: string): boolean {
+        return this.timelineSet.findEventById(eventId) instanceof MatrixEvent;
+    }
+
+    public toJson(): ISerialisedThread {
+        return {
+            id: this.id,
+            tails: Array.from(this.tail),
+        };
+    }
+
+    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;
+    }
+}
@@ -208,7 +208,7 @@ export class User extends EventEmitter {
     * @param {MatrixEvent} event The <code>im.vector.user_status</code> event.
     * @fires module:client~MatrixClient#event:"User.unstable_statusMessage"
     */
-    // eslint-disable-next-line camelcase
+    // eslint-disable-next-line
    public unstable_updateStatusMessage(event: MatrixEvent): void {
        if (!event.getContent()) this.unstable_statusMessage = "";
        else this.unstable_statusMessage = event.getContent()["status"];
@@ -1,6 +1,5 @@
 /*
-Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2017 New Vector Ltd
+Copyright 2015 - 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.
@@ -17,12 +16,36 @@ limitations under the License.

 import { escapeRegExp, globToRegexp, isNullOrUndefined } from "./utils";
 import { logger } from './logger';
+import { MatrixClient } from "./client";
+import { MatrixEvent } from "./models/event";
+import {
+    ConditionKind,
+    IAnnotatedPushRule,
+    IContainsDisplayNameCondition,
+    IEventMatchCondition,
+    IPushRule,
+    IPushRules,
+    IRoomMemberCountCondition,
+    ISenderNotificationPermissionCondition,
+    PushRuleAction,
+    PushRuleActionName,
+    PushRuleCondition,
+    PushRuleKind,
+    PushRuleSet,
+    TweakName,
+} from "./@types/PushRules";

 /**
 * @module pushprocessor
 */

-const RULEKINDS_IN_ORDER = ['override', 'content', 'room', 'sender', 'underride'];
+const RULEKINDS_IN_ORDER = [
+    PushRuleKind.Override,
+    PushRuleKind.ContentSpecific,
+    PushRuleKind.RoomSpecific,
+    PushRuleKind.SenderSpecific,
+    PushRuleKind.Underride,
+];

 // The default override rules to apply to the push rules that arrive from the server.
 // We do this for two reasons:
@@ -31,7 +54,7 @@ const RULEKINDS_IN_ORDER = ['override', 'content', 'room', 'sender', 'underride'
 //      more details.
 //   2. We often want to start using push rules ahead of the server supporting them,
 //      and so we can put them here.
-const DEFAULT_OVERRIDE_RULES = [
+const DEFAULT_OVERRIDE_RULES: IPushRule[] = [
    {
        // For homeservers which don't support MSC1930 yet
        rule_id: ".m.rule.tombstone",
@@ -39,20 +62,20 @@ const DEFAULT_OVERRIDE_RULES = [
        enabled: true,
        conditions: [
            {
-                kind: "event_match",
+                kind: ConditionKind.EventMatch,
                key: "type",
                pattern: "m.room.tombstone",
            },
            {
-                kind: "event_match",
+                kind: ConditionKind.EventMatch,
                key: "state_key",
                pattern: "",
            },
        ],
        actions: [
-            "notify",
+            PushRuleActionName.Notify,
            {
-                set_tweak: "highlight",
+                set_tweak: TweakName.Highlight,
                value: true,
            },
        ],
@@ -64,31 +87,97 @@ const DEFAULT_OVERRIDE_RULES = [
        enabled: true,
        conditions: [
            {
-                kind: "event_match",
+                kind: ConditionKind.EventMatch,
                key: "type",
                pattern: "m.reaction",
            },
        ],
        actions: [
-            "dont_notify",
+            PushRuleActionName.DontNotify,
        ],
    },
 ];

-/**
- * Construct a Push Processor.
- * @constructor
- * @param {Object} client The Matrix client object to use
- */
-export function PushProcessor(client) {
-    const cachedGlobToRegex = {
-        // $glob: RegExp,
-    };
+export interface IActionsObject {
+    notify: boolean;
+    tweaks: Partial<Record<TweakName, any>>;
+}

-    const matchingRuleFromKindSet = (ev, kindset) => {
-        for (let ruleKindIndex = 0;
-                ruleKindIndex < RULEKINDS_IN_ORDER.length;
-                ++ruleKindIndex) {
+export class PushProcessor {
+    /**
+     * Construct a Push Processor.
+     * @constructor
+     * @param {Object} client The Matrix client object to use
+     */
+    constructor(private readonly client: MatrixClient) {}
+
+    /**
+     * Convert a list of actions into a object with the actions as keys and their values
+     * eg. [ 'notify', { set_tweak: 'sound', value: 'default' } ]
+     *     becomes { notify: true, tweaks: { sound: 'default' } }
+     * @param {array} actionList The actions list
+     *
+     * @return {object} A object with key 'notify' (true or false) and an object of actions
+     */
+    public static actionListToActionsObject(actionList: PushRuleAction[]): IActionsObject {
+        const actionObj: IActionsObject = { notify: false, tweaks: {} };
+        for (let i = 0; i < actionList.length; ++i) {
+            const action = actionList[i];
+            if (action === PushRuleActionName.Notify) {
+                actionObj.notify = true;
+            } else if (typeof action === 'object') {
+                if (action.value === undefined) {
+                    action.value = true;
+                }
+                actionObj.tweaks[action.set_tweak] = action.value;
+            }
+        }
+        return actionObj;
+    }
+
+    /**
+     * Rewrites conditions on a client's push rules to match the defaults
+     * where applicable. Useful for upgrading push rules to more strict
+     * conditions when the server is falling behind on defaults.
+     * @param {object} incomingRules The client's existing push rules
+     * @returns {object} The rewritten rules
+     */
+    public static rewriteDefaultRules(incomingRules: IPushRules): IPushRules {
+        let newRules: IPushRules = JSON.parse(JSON.stringify(incomingRules)); // deep clone
+
+        // These lines are mostly to make the tests happy. We shouldn't run into these
+        // properties missing in practice.
+        if (!newRules) newRules = {} as IPushRules;
+        if (!newRules.global) newRules.global = {} as PushRuleSet;
+        if (!newRules.global.override) newRules.global.override = [];
+
+        // Merge the client-level defaults with the ones from the server
+        const globalOverrides = newRules.global.override;
+        for (const override of DEFAULT_OVERRIDE_RULES) {
+            const existingRule = globalOverrides
+                .find((r) => r.rule_id === override.rule_id);
+
+            if (existingRule) {
+                // Copy over the actions, default, and conditions. Don't touch the user's
+                // preference.
+                existingRule.default = override.default;
+                existingRule.conditions = override.conditions;
+                existingRule.actions = override.actions;
+            } else {
+                // Add the rule
+                const ruleId = override.rule_id;
+                logger.warn(`Adding default global override for ${ruleId}`);
+                globalOverrides.push(override);
+            }
+        }
+
+        return newRules;
+    }
+
+    private static cachedGlobToRegex: Record<string, RegExp> = {}; // $glob: RegExp
+
+    private matchingRuleFromKindSet(ev: MatrixEvent, kindset: PushRuleSet): IAnnotatedPushRule {
+        for (let ruleKindIndex = 0; ruleKindIndex < RULEKINDS_IN_ORDER.length; ++ruleKindIndex) {
            const kind = RULEKINDS_IN_ORDER[ruleKindIndex];
            const ruleset = kindset[kind];
            if (!ruleset) {
@@ -101,89 +190,96 @@ export function PushProcessor(client) {
                    continue;
                }

-                const rawrule = templateRuleToRaw(kind, rule);
+                const rawrule = this.templateRuleToRaw(kind, rule);
                if (!rawrule) {
                    continue;
                }

                if (this.ruleMatchesEvent(rawrule, ev)) {
-                    rule.kind = kind;
-                    return rule;
+                    return {
+                        ...rule,
+                        kind,
+                    };
                }
            }
        }
        return null;
-    };
+    }

-    const templateRuleToRaw = function(kind, tprule) {
+    private templateRuleToRaw(kind: PushRuleKind, tprule: any): any {
        const rawrule = {
            'rule_id': tprule.rule_id,
            'actions': tprule.actions,
            'conditions': [],
        };
        switch (kind) {
-            case 'underride':
-            case 'override':
+            case PushRuleKind.Underride:
+            case PushRuleKind.Override:
                rawrule.conditions = tprule.conditions;
                break;
-            case 'room':
+            case PushRuleKind.RoomSpecific:
                if (!tprule.rule_id) {
                    return null;
                }
                rawrule.conditions.push({
-                    'kind': 'event_match',
+                    'kind': ConditionKind.EventMatch,
                    'key': 'room_id',
                    'value': tprule.rule_id,
                });
                break;
-            case 'sender':
+            case PushRuleKind.SenderSpecific:
                if (!tprule.rule_id) {
                    return null;
                }
                rawrule.conditions.push({
-                    'kind': 'event_match',
+                    'kind': ConditionKind.EventMatch,
                    'key': 'user_id',
                    'value': tprule.rule_id,
                });
                break;
-            case 'content':
+            case PushRuleKind.ContentSpecific:
                if (!tprule.pattern) {
                    return null;
                }
                rawrule.conditions.push({
-                    'kind': 'event_match',
+                    'kind': ConditionKind.EventMatch,
                    'key': 'content.body',
                    'pattern': tprule.pattern,
                });
                break;
        }
        return rawrule;
-    };
+    }

-    const eventFulfillsCondition = function(cond, ev) {
-        const condition_functions = {
-            "event_match": eventFulfillsEventMatchCondition,
-            "contains_display_name": eventFulfillsDisplayNameCondition,
-            "room_member_count": eventFulfillsRoomMemberCountCondition,
-            "sender_notification_permission": eventFulfillsSenderNotifPermCondition,
-        };
-        if (condition_functions[cond.kind]) {
-            return condition_functions[cond.kind](cond, ev);
+    private eventFulfillsCondition(cond: PushRuleCondition, ev: MatrixEvent): boolean {
+        switch (cond.kind) {
+            case ConditionKind.EventMatch:
+                return this.eventFulfillsEventMatchCondition(cond, ev);
+            case ConditionKind.ContainsDisplayName:
+                return this.eventFulfillsDisplayNameCondition(cond, ev);
+            case ConditionKind.RoomMemberCount:
+                return this.eventFulfillsRoomMemberCountCondition(cond, ev);
+            case ConditionKind.SenderNotificationPermission:
+                return this.eventFulfillsSenderNotifPermCondition(cond, ev);
        }
+
        // unknown conditions: we previously matched all unknown conditions,
        // but given that rules can be added to the base rules on a server,
        // it's probably better to not match unknown conditions.
        return false;
-    };
+    }

-    const eventFulfillsSenderNotifPermCondition = function(cond, ev) {
+    private eventFulfillsSenderNotifPermCondition(
+        cond: ISenderNotificationPermissionCondition,
+        ev: MatrixEvent,
+    ): boolean {
        const notifLevelKey = cond['key'];
        if (!notifLevelKey) {
            return false;
        }

-        const room = client.getRoom(ev.getRoomId());
-        if (!room || !room.currentState) {
+        const room = this.client.getRoom(ev.getRoomId());
+        if (!room?.currentState) {
            return false;
        }

@@ -191,14 +287,14 @@ export function PushProcessor(client) {
        // the point the event is in the DAG. Unfortunately the js-sdk does not store
        // this.
        return room.currentState.mayTriggerNotifOfType(notifLevelKey, ev.getSender());
-    };
+    }

-    const eventFulfillsRoomMemberCountCondition = function(cond, ev) {
+    private eventFulfillsRoomMemberCountCondition(cond: IRoomMemberCountCondition, ev: MatrixEvent): boolean {
        if (!cond.is) {
            return false;
        }

-        const room = client.getRoom(ev.getRoomId());
+        const room = this.client.getRoom(ev.getRoomId());
        if (!room || !room.currentState || !room.currentState.members) {
            return false;
        }
@@ -229,9 +325,9 @@ export function PushProcessor(client) {
            default:
                return false;
        }
-    };
+    }

-    const eventFulfillsDisplayNameCondition = function(cond, ev) {
+    private eventFulfillsDisplayNameCondition(cond: IContainsDisplayNameCondition, ev: MatrixEvent): boolean {
        let content = ev.getContent();
        if (ev.isEncrypted() && ev.getClearContent()) {
            content = ev.getClearContent();
@@ -240,26 +336,26 @@ export function PushProcessor(client) {
            return false;
        }

-        const room = client.getRoom(ev.getRoomId());
+        const room = this.client.getRoom(ev.getRoomId());
        if (!room || !room.currentState || !room.currentState.members ||
-            !room.currentState.getMember(client.credentials.userId)) {
+            !room.currentState.getMember(this.client.credentials.userId)) {
            return false;
        }

-        const displayName = room.currentState.getMember(client.credentials.userId).name;
+        const displayName = room.currentState.getMember(this.client.credentials.userId).name;

        // N.B. we can't use \b as it chokes on unicode. however \W seems to be okay
        // as shorthand for [^0-9A-Za-z_].
        const pat = new RegExp("(^|\\W)" + escapeRegExp(displayName) + "(\\W|$)", 'i');
        return content.body.search(pat) > -1;
-    };
+    }

-    const eventFulfillsEventMatchCondition = function(cond, ev) {
+    private eventFulfillsEventMatchCondition(cond: IEventMatchCondition, ev: MatrixEvent): boolean {
        if (!cond.key) {
            return false;
        }

-        const val = valueForDottedKey(cond.key, ev);
+        const val = this.valueForDottedKey(cond.key, ev);
        if (typeof val !== 'string') {
            return false;
        }
@@ -275,26 +371,26 @@ export function PushProcessor(client) {
        let regex;

        if (cond.key == 'content.body') {
-            regex = createCachedRegex('(^|\\W)', cond.pattern, '(\\W|$)');
+            regex = this.createCachedRegex('(^|\\W)', cond.pattern, '(\\W|$)');
        } else {
-            regex = createCachedRegex('^', cond.pattern, '$');
+            regex = this.createCachedRegex('^', cond.pattern, '$');
        }

        return !!val.match(regex);
-    };
+    }

-    const createCachedRegex = function(prefix, glob, suffix) {
-        if (cachedGlobToRegex[glob]) {
-            return cachedGlobToRegex[glob];
+    private createCachedRegex(prefix: string, glob: string, suffix: string): RegExp {
+        if (PushProcessor.cachedGlobToRegex[glob]) {
+            return PushProcessor.cachedGlobToRegex[glob];
        }
-        cachedGlobToRegex[glob] = new RegExp(
+        PushProcessor.cachedGlobToRegex[glob] = new RegExp(
            prefix + globToRegexp(glob) + suffix,
            'i', // Case insensitive
        );
-        return cachedGlobToRegex[glob];
-    };
+        return PushProcessor.cachedGlobToRegex[glob];
+    }

-    const valueForDottedKey = function(key, ev) {
+    private valueForDottedKey(key: string, ev: MatrixEvent): any {
        const parts = key.split('.');
        let val;

@@ -319,23 +415,23 @@ export function PushProcessor(client) {
            val = val[thisPart];
        }
        return val;
-    };
+    }

-    const matchingRuleForEventWithRulesets = function(ev, rulesets) {
+    private matchingRuleForEventWithRulesets(ev: MatrixEvent, rulesets): IAnnotatedPushRule {
        if (!rulesets) {
            return null;
        }
-        if (ev.getSender() === client.credentials.userId) {
+        if (ev.getSender() === this.client.credentials.userId) {
            return null;
        }

-        return matchingRuleFromKindSet(ev, rulesets.global);
-    };
+        return this.matchingRuleFromKindSet(ev, rulesets.global);
+    }

-    const pushActionsForEventAndRulesets = function(ev, rulesets) {
-        const rule = matchingRuleForEventWithRulesets(ev, rulesets);
+    private pushActionsForEventAndRulesets(ev: MatrixEvent, rulesets): IActionsObject {
+        const rule = this.matchingRuleForEventWithRulesets(ev, rulesets);
        if (!rule) {
-            return {};
+            return {} as IActionsObject;
        }

        const actionObj = PushProcessor.actionListToActionsObject(rule.actions);
@@ -344,21 +440,22 @@ export function PushProcessor(client) {
        if (actionObj.tweaks.highlight === undefined) {
            // if it isn't specified, highlight if it's a content
            // rule but otherwise not
-            actionObj.tweaks.highlight = (rule.kind == 'content');
+            actionObj.tweaks.highlight = (rule.kind == PushRuleKind.ContentSpecific);
        }

        return actionObj;
-    };
+    }

-    this.ruleMatchesEvent = function(rule, ev) {
+    public ruleMatchesEvent(rule: IPushRule, ev: MatrixEvent): boolean {
        let ret = true;
        for (let i = 0; i < rule.conditions.length; ++i) {
            const cond = rule.conditions[i];
-            ret &= eventFulfillsCondition(cond, ev);
+            // @ts-ignore
+            ret &= this.eventFulfillsCondition(cond, ev);
        }
        //console.log("Rule "+rule.rule_id+(ret ? " matches" : " doesn't match"));
        return ret;
-    };
+    }

    /**
     * Get the user's push actions for the given event
@@ -367,9 +464,9 @@ export function PushProcessor(client) {
     *
     * @return {PushAction}
     */
-    this.actionsForEvent = function(ev) {
-        return pushActionsForEventAndRulesets(ev, client.pushRules);
-    };
+    public actionsForEvent(ev: MatrixEvent): IActionsObject {
+        return this.pushActionsForEventAndRulesets(ev, this.client.pushRules);
+    }

    /**
     * Get one of the users push rules by its ID
@@ -377,85 +474,22 @@ export function PushProcessor(client) {
     * @param {string} ruleId The ID of the rule to search for
     * @return {object} The push rule, or null if no such rule was found
     */
-    this.getPushRuleById = function(ruleId) {
+    public getPushRuleById(ruleId: string): IPushRule {
        for (const scope of ['global']) {
-            if (client.pushRules[scope] === undefined) continue;
+            if (this.client.pushRules[scope] === undefined) continue;

            for (const kind of RULEKINDS_IN_ORDER) {
-                if (client.pushRules[scope][kind] === undefined) continue;
+                if (this.client.pushRules[scope][kind] === undefined) continue;

-                for (const rule of client.pushRules[scope][kind]) {
+                for (const rule of this.client.pushRules[scope][kind]) {
                    if (rule.rule_id === ruleId) return rule;
                }
            }
        }
        return null;
-    };
+    }
 }

-/**
- * Convert a list of actions into a object with the actions as keys and their values
- * eg. [ 'notify', { set_tweak: 'sound', value: 'default' } ]
- *     becomes { notify: true, tweaks: { sound: 'default' } }
- * @param {array} actionlist The actions list
- *
- * @return {object} A object with key 'notify' (true or false) and an object of actions
- */
-PushProcessor.actionListToActionsObject = function(actionlist) {
-    const actionobj = { 'notify': false, 'tweaks': {} };
-    for (let i = 0; i < actionlist.length; ++i) {
-        const action = actionlist[i];
-        if (action === 'notify') {
-            actionobj.notify = true;
-        } else if (typeof action === 'object') {
-            if (action.value === undefined) {
-                action.value = true;
-            }
-            actionobj.tweaks[action.set_tweak] = action.value;
-        }
-    }
-    return actionobj;
-};
-
-/**
- * Rewrites conditions on a client's push rules to match the defaults
- * where applicable. Useful for upgrading push rules to more strict
- * conditions when the server is falling behind on defaults.
- * @param {object} incomingRules The client's existing push rules
- * @returns {object} The rewritten rules
- */
-PushProcessor.rewriteDefaultRules = function(incomingRules) {
-    let newRules = JSON.parse(JSON.stringify(incomingRules)); // deep clone
-
-    // These lines are mostly to make the tests happy. We shouldn't run into these
-    // properties missing in practice.
-    if (!newRules) newRules = {};
-    if (!newRules.global) newRules.global = {};
-    if (!newRules.global.override) newRules.global.override = [];
-
-    // Merge the client-level defaults with the ones from the server
-    const globalOverrides = newRules.global.override;
-    for (const override of DEFAULT_OVERRIDE_RULES) {
-        const existingRule = globalOverrides
-            .find((r) => r.rule_id === override.rule_id);
-
-        if (existingRule) {
-            // Copy over the actions, default, and conditions. Don't touch the user's
-            // preference.
-            existingRule.default = override.default;
-            existingRule.conditions = override.conditions;
-            existingRule.actions = override.actions;
-        } else {
-            // Add the rule
-            const ruleId = override.rule_id;
-            logger.warn(`Adding default global override for ${ruleId}`);
-            globalOverrides.push(override);
-        }
-    }
-
-    return newRules;
-};
-
 /**
 * @typedef {Object} PushAction
 * @type {Object}
@@ -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;
@@ -0,0 +1,153 @@
+/*
+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.
+*/
+
+/**
+ * @module room-hierarchy
+ */
+
+import { Room } from "./models/room";
+import { IHierarchyRoom, IHierarchyRelation } from "./@types/spaces";
+import { MatrixClient } from "./client";
+import { EventType } from "./@types/event";
+
+export class RoomHierarchy {
+    // Map from room id to list of servers which are listed as a via somewhere in the loaded hierarchy
+    public readonly viaMap = new Map<string, Set<string>>();
+    // Map from room id to list of rooms which claim this room as their child
+    public readonly backRefs = new Map<string, string[]>();
+    // Map from room id to object
+    public readonly roomMap = new Map<string, IHierarchyRoom>();
+    private loadRequest: ReturnType<MatrixClient["getRoomHierarchy"]>;
+    private nextBatch?: string;
+    private _rooms?: IHierarchyRoom[];
+    private serverSupportError?: Error;
+
+    /**
+     * Construct a new RoomHierarchy
+     *
+     * A RoomHierarchy instance allows you to easily make use of the /hierarchy API and paginate it.
+     *
+     * @param {Room} root the root of this hierarchy
+     * @param {number} pageSize the maximum number of rooms to return per page, can be overridden per load request.
+     * @param {number} maxDepth the maximum depth to traverse the hierarchy to
+     * @param {boolean} suggestedOnly whether to only return rooms with suggested=true.
+     * @constructor
+     */
+    constructor(
+        public readonly root: Room,
+        private readonly pageSize?: number,
+        private readonly maxDepth?: number,
+        private readonly suggestedOnly = false,
+    ) {}
+
+    public get noSupport(): boolean {
+        return !!this.serverSupportError;
+    }
+
+    public get canLoadMore(): boolean {
+        return !!this.serverSupportError || !!this.nextBatch || !this._rooms;
+    }
+
+    public get loading(): boolean {
+        return !!this.loadRequest;
+    }
+
+    public get rooms(): IHierarchyRoom[] {
+        return this._rooms;
+    }
+
+    public async load(pageSize = this.pageSize): Promise<IHierarchyRoom[]> {
+        if (this.loadRequest) return this.loadRequest.then(r => r.rooms);
+
+        this.loadRequest = this.root.client.getRoomHierarchy(
+            this.root.roomId,
+            pageSize,
+            this.maxDepth,
+            this.suggestedOnly,
+            this.nextBatch,
+        );
+
+        let rooms: IHierarchyRoom[];
+        try {
+            ({ rooms, next_batch: this.nextBatch } = await this.loadRequest);
+        } catch (e) {
+            if (e.errcode === "M_UNRECOGNIZED") {
+                this.serverSupportError = e;
+            } else {
+                throw e;
+            }
+
+            return [];
+        } finally {
+            this.loadRequest = null;
+        }
+
+        if (this._rooms) {
+            this._rooms = this._rooms.concat(rooms);
+        } else {
+            this._rooms = rooms;
+        }
+
+        rooms.forEach(room => {
+            this.roomMap.set(room.room_id, room);
+
+            room.children_state.forEach(ev => {
+                if (ev.type !== EventType.SpaceChild) return;
+                const childRoomId = ev.state_key;
+
+                // track backrefs for quicker hierarchy navigation
+                if (!this.backRefs.has(childRoomId)) {
+                    this.backRefs.set(childRoomId, []);
+                }
+                this.backRefs.get(childRoomId).push(ev.room_id);
+
+                // fill viaMap
+                if (Array.isArray(ev.content.via)) {
+                    if (!this.viaMap.has(childRoomId)) {
+                        this.viaMap.set(childRoomId, new Set());
+                    }
+                    const vias = this.viaMap.get(childRoomId);
+                    ev.content.via.forEach(via => vias.add(via));
+                }
+            });
+        });
+
+        return rooms;
+    }
+
+    public getRelation(parentId: string, childId: string): IHierarchyRelation {
+        return this.roomMap.get(parentId)?.children_state.find(e => e.state_key === childId);
+    }
+
+    public isSuggested(parentId: string, childId: string): boolean {
+        return this.getRelation(parentId, childId)?.content.suggested;
+    }
+
+    // locally remove a relation as a form of local echo
+    public removeRelation(parentId: string, childId: string): void {
+        const backRefs = this.backRefs.get(childId);
+        if (backRefs?.length === 1) {
+            this.backRefs.delete(childId);
+        } else if (backRefs?.length) {
+            this.backRefs.set(childId, backRefs.filter(ref => ref !== parentId));
+        }
+
+        const room = this.roomMap.get(parentId);
+        if (room) {
+            room.children_state = room.children_state.filter(ev => ev.state_key !== childId);
+        }
+    }
+}
@@ -1,327 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2019 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.
-*/
-
-/**
- * This is an internal module which manages queuing, scheduling and retrying
- * of requests.
- * @module scheduler
- */
-import * as utils from "./utils";
-import { logger } from './logger';
-
-const DEBUG = false;  // set true to enable console logging.
-
-/**
- * Construct a scheduler for Matrix. Requires
- * {@link module:scheduler~MatrixScheduler#setProcessFunction} to be provided
- * with a way of processing events.
- * @constructor
- * @param {module:scheduler~retryAlgorithm} retryAlgorithm Optional. The retry
- * algorithm to apply when determining when to try to send an event again.
- * Defaults to {@link module:scheduler~MatrixScheduler.RETRY_BACKOFF_RATELIMIT}.
- * @param {module:scheduler~queueAlgorithm} queueAlgorithm Optional. The queuing
- * algorithm to apply when determining which events should be sent before the
- * given event. Defaults to {@link module:scheduler~MatrixScheduler.QUEUE_MESSAGES}.
- */
-export function MatrixScheduler(retryAlgorithm, queueAlgorithm) {
-    this.retryAlgorithm = retryAlgorithm || MatrixScheduler.RETRY_BACKOFF_RATELIMIT;
-    this.queueAlgorithm = queueAlgorithm || MatrixScheduler.QUEUE_MESSAGES;
-    this._queues = {
-        // queueName: [{
-        //  event: MatrixEvent,  // event to send
-        //  defer: Deferred,  // defer to resolve/reject at the END of the retries
-        //  attempts: Number  // number of times we've called processFn
-        // }, ...]
-    };
-    this._activeQueues = [];
-    this._procFn = null;
-}
-
-/**
- * Retrieve a queue based on an event. The event provided does not need to be in
- * the queue.
- * @param {MatrixEvent} event An event to get the queue for.
- * @return {?Array<MatrixEvent>} A shallow copy of events in the queue or null.
- * Modifying this array will not modify the list itself. Modifying events in
- * this array <i>will</i> modify the underlying event in the queue.
- * @see MatrixScheduler.removeEventFromQueue To remove an event from the queue.
- */
-MatrixScheduler.prototype.getQueueForEvent = function(event) {
-    const name = this.queueAlgorithm(event);
-    if (!name || !this._queues[name]) {
-        return null;
-    }
-    return this._queues[name].map(function(obj) {
-        return obj.event;
-    });
-};
-
-/**
- * Remove this event from the queue. The event is equal to another event if they
- * have the same ID returned from event.getId().
- * @param {MatrixEvent} event The event to remove.
- * @return {boolean} True if this event was removed.
- */
-MatrixScheduler.prototype.removeEventFromQueue = function(event) {
-    const name = this.queueAlgorithm(event);
-    if (!name || !this._queues[name]) {
-        return false;
-    }
-    let removed = false;
-    utils.removeElement(this._queues[name], function(element) {
-        if (element.event.getId() === event.getId()) {
-            // XXX we should probably reject the promise?
-            // https://github.com/matrix-org/matrix-js-sdk/issues/496
-            removed = true;
-            return true;
-        }
-    });
-    return removed;
-};
-
-/**
- * Set the process function. Required for events in the queue to be processed.
- * If set after events have been added to the queue, this will immediately start
- * processing them.
- * @param {module:scheduler~processFn} fn The function that can process events
- * in the queue.
- */
-MatrixScheduler.prototype.setProcessFunction = function(fn) {
-    this._procFn = fn;
-    _startProcessingQueues(this);
-};
-
-/**
- * Queue an event if it is required and start processing queues.
- * @param {MatrixEvent} event The event that may be queued.
- * @return {?Promise} A promise if the event was queued, which will be
- * resolved or rejected in due time, else null.
- */
-MatrixScheduler.prototype.queueEvent = function(event) {
-    const queueName = this.queueAlgorithm(event);
-    if (!queueName) {
-        return null;
-    }
-    // add the event to the queue and make a deferred for it.
-    if (!this._queues[queueName]) {
-        this._queues[queueName] = [];
-    }
-    const defer = utils.defer();
-    this._queues[queueName].push({
-        event: event,
-        defer: defer,
-        attempts: 0,
-    });
-    debuglog(
-        "Queue algorithm dumped event %s into queue '%s'",
-        event.getId(), queueName,
-    );
-    _startProcessingQueues(this);
-    return defer.promise;
-};
-
-/**
- * Retries events up to 4 times using exponential backoff. This produces wait
- * times of 2, 4, 8, and 16 seconds (30s total) after which we give up. If the
- * failure was due to a rate limited request, the time specified in the error is
- * waited before being retried.
- * @param {MatrixEvent} event
- * @param {Number} attempts
- * @param {MatrixError} err
- * @return {Number}
- * @see module:scheduler~retryAlgorithm
- */
-MatrixScheduler.RETRY_BACKOFF_RATELIMIT = function(event, attempts, err) {
-    if (err.httpStatus === 400 || err.httpStatus === 403 || err.httpStatus === 401) {
-        // client error; no amount of retrying with save you now.
-        return -1;
-    }
-    // we ship with browser-request which returns { cors: rejected } when trying
-    // with no connection, so if we match that, give up since they have no conn.
-    if (err.cors === "rejected") {
-        return -1;
-    }
-
-    // if event that we are trying to send is too large in any way then retrying won't help
-    if (err.name === "M_TOO_LARGE") {
-        return -1;
-    }
-
-    if (err.name === "M_LIMIT_EXCEEDED") {
-        const waitTime = err.data.retry_after_ms;
-        if (waitTime > 0) {
-            return waitTime;
-        }
-    }
-    if (attempts > 4) {
-        return -1; // give up
-    }
-    return (1000 * Math.pow(2, attempts));
-};
-
-/**
- * Queues <code>m.room.message</code> events and lets other events continue
- * concurrently.
- * @param {MatrixEvent} event
- * @return {string}
- * @see module:scheduler~queueAlgorithm
- */
-MatrixScheduler.QUEUE_MESSAGES = function(event) {
-    // enqueue messages or events that associate with another event (redactions and relations)
-    if (event.getType() === "m.room.message" || event.hasAssocation()) {
-        // put these events in the 'message' queue.
-        return "message";
-    }
-    // allow all other events continue concurrently.
-    return null;
-};
-
-function _startProcessingQueues(scheduler) {
-    if (!scheduler._procFn) {
-        return;
-    }
-    // for each inactive queue with events in them
-    Object.keys(scheduler._queues)
-        .filter(function(queueName) {
-            return scheduler._activeQueues.indexOf(queueName) === -1 &&
-                    scheduler._queues[queueName].length > 0;
-        })
-        .forEach(function(queueName) {
-            // mark the queue as active
-            scheduler._activeQueues.push(queueName);
-            // begin processing the head of the queue
-            debuglog("Spinning up queue: '%s'", queueName);
-            _processQueue(scheduler, queueName);
-        });
-}
-
-function _processQueue(scheduler, queueName) {
-    // get head of queue
-    const obj = _peekNextEvent(scheduler, queueName);
-    if (!obj) {
-        // queue is empty. Mark as inactive and stop recursing.
-        const index = scheduler._activeQueues.indexOf(queueName);
-        if (index >= 0) {
-            scheduler._activeQueues.splice(index, 1);
-        }
-        debuglog("Stopping queue '%s' as it is now empty", queueName);
-        return;
-    }
-    debuglog(
-        "Queue '%s' has %s pending events",
-        queueName, scheduler._queues[queueName].length,
-    );
-    // fire the process function and if it resolves, resolve the deferred. Else
-    // invoke the retry algorithm.
-
-    // First wait for a resolved promise, so the resolve handlers for
-    // the deferred of the previously sent event can run.
-    // This way enqueued relations/redactions to enqueued events can receive
-    // the remove id of their target before being sent.
-    Promise.resolve().then(() => {
-        return scheduler._procFn(obj.event);
-    }).then(function(res) {
-        // remove this from the queue
-        _removeNextEvent(scheduler, queueName);
-        debuglog("Queue '%s' sent event %s", queueName, obj.event.getId());
-        obj.defer.resolve(res);
-        // keep processing
-        _processQueue(scheduler, queueName);
-    }, function(err) {
-        obj.attempts += 1;
-        // ask the retry algorithm when/if we should try again
-        const waitTimeMs = scheduler.retryAlgorithm(obj.event, obj.attempts, err);
-        debuglog(
-            "retry(%s) err=%s event_id=%s waitTime=%s",
-            obj.attempts, err, obj.event.getId(), waitTimeMs,
-        );
-        if (waitTimeMs === -1) {  // give up (you quitter!)
-            debuglog(
-                "Queue '%s' giving up on event %s", queueName, obj.event.getId(),
-            );
-            // remove this from the queue
-            _removeNextEvent(scheduler, queueName);
-            obj.defer.reject(err);
-            // process next event
-            _processQueue(scheduler, queueName);
-        } else {
-            setTimeout(function() {
-                _processQueue(scheduler, queueName);
-            }, waitTimeMs);
-        }
-    });
-}
-
-function _peekNextEvent(scheduler, queueName) {
-    const queue = scheduler._queues[queueName];
-    if (!Array.isArray(queue)) {
-        return null;
-    }
-    return queue[0];
-}
-
-function _removeNextEvent(scheduler, queueName) {
-    const queue = scheduler._queues[queueName];
-    if (!Array.isArray(queue)) {
-        return null;
-    }
-    return queue.shift();
-}
-
-function debuglog() {
-    if (DEBUG) {
-        logger.log(...arguments);
-    }
-}
-
-/**
- * The retry algorithm to apply when retrying events. To stop retrying, return
- * <code>-1</code>. If this event was part of a queue, it will be removed from
- * the queue.
- * @callback retryAlgorithm
- * @param {MatrixEvent} event The event being retried.
- * @param {Number} attempts The number of failed attempts. This will always be
- * >= 1.
- * @param {MatrixError} err The most recent error message received when trying
- * to send this event.
- * @return {Number} The number of milliseconds to wait before trying again. If
- * this is 0, the request will be immediately retried. If this is
- * <code>-1</code>, the event will be marked as
- * {@link module:models/event.EventStatus.NOT_SENT} and will not be retried.
- */
-
-/**
- * The queuing algorithm to apply to events. This function must be idempotent as
- * it may be called multiple times with the same event. All queues created are
- * serviced in a FIFO manner. To send the event ASAP, return <code>null</code>
- * which will not put this event in a queue. Events that fail to send that form
- * part of a queue will be removed from the queue and the next event in the
- * queue will be sent.
- * @callback queueAlgorithm
- * @param {MatrixEvent} event The event to be sent.
- * @return {string} The name of the queue to put the event into. If a queue with
- * this name does not exist, it will be created. If this is <code>null</code>,
- * the event is not put into a queue and will be sent concurrently.
- */
-
- /**
- * The function to invoke to process (send) events in the queue.
- * @callback processFn
- * @param {MatrixEvent} event The event to send.
- * @return {Promise} Resolved/rejected depending on the outcome of the request.
- */
-
@@ -0,0 +1,329 @@
+/*
+Copyright 2015 - 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.
+*/
+
+/**
+ * This is an internal module which manages queuing, scheduling and retrying
+ * of requests.
+ * @module scheduler
+ */
+import * as utils from "./utils";
+import { logger } from './logger';
+import { MatrixEvent } from "./models/event";
+import { EventType } from "./@types/event";
+import { IDeferred } from "./utils";
+import { MatrixError } from "./http-api";
+import { ISendEventResponse } from "./@types/requests";
+
+const DEBUG = false;  // set true to enable console logging.
+
+interface IQueueEntry<T> {
+    event: MatrixEvent;
+    defer: IDeferred<T>;
+    attempts: number;
+}
+
+type ProcessFunction<T> = (event: MatrixEvent) => Promise<T>;
+
+/**
+ * Construct a scheduler for Matrix. Requires
+ * {@link module:scheduler~MatrixScheduler#setProcessFunction} to be provided
+ * with a way of processing events.
+ * @constructor
+ * @param {module:scheduler~retryAlgorithm} retryAlgorithm Optional. The retry
+ * algorithm to apply when determining when to try to send an event again.
+ * Defaults to {@link module:scheduler~MatrixScheduler.RETRY_BACKOFF_RATELIMIT}.
+ * @param {module:scheduler~queueAlgorithm} queueAlgorithm Optional. The queuing
+ * algorithm to apply when determining which events should be sent before the
+ * given event. Defaults to {@link module:scheduler~MatrixScheduler.QUEUE_MESSAGES}.
+ */
+// eslint-disable-next-line camelcase
+export class MatrixScheduler<T = ISendEventResponse> {
+    /**
+     * Retries events up to 4 times using exponential backoff. This produces wait
+     * times of 2, 4, 8, and 16 seconds (30s total) after which we give up. If the
+     * failure was due to a rate limited request, the time specified in the error is
+     * waited before being retried.
+     * @param {MatrixEvent} event
+     * @param {Number} attempts
+     * @param {MatrixError} err
+     * @return {Number}
+     * @see module:scheduler~retryAlgorithm
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public static RETRY_BACKOFF_RATELIMIT(event: MatrixEvent, attempts: number, err: MatrixError): number {
+        if (err.httpStatus === 400 || err.httpStatus === 403 || err.httpStatus === 401) {
+            // client error; no amount of retrying with save you now.
+            return -1;
+        }
+        // we ship with browser-request which returns { cors: rejected } when trying
+        // with no connection, so if we match that, give up since they have no conn.
+        if (err.cors === "rejected") {
+            return -1;
+        }
+
+        // if event that we are trying to send is too large in any way then retrying won't help
+        if (err.name === "M_TOO_LARGE") {
+            return -1;
+        }
+
+        if (err.name === "M_LIMIT_EXCEEDED") {
+            const waitTime = err.data.retry_after_ms;
+            if (waitTime > 0) {
+                return waitTime;
+            }
+        }
+        if (attempts > 4) {
+            return -1; // give up
+        }
+        return (1000 * Math.pow(2, attempts));
+    }
+
+    /**
+     * Queues <code>m.room.message</code> events and lets other events continue
+     * concurrently.
+     * @param {MatrixEvent} event
+     * @return {string}
+     * @see module:scheduler~queueAlgorithm
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public static QUEUE_MESSAGES(event: MatrixEvent) {
+        // enqueue messages or events that associate with another event (redactions and relations)
+        if (event.getType() === EventType.RoomMessage || event.hasAssocation()) {
+            // put these events in the 'message' queue.
+            return "message";
+        }
+        // allow all other events continue concurrently.
+        return null;
+    }
+
+    // queueName: [{
+    //  event: MatrixEvent,  // event to send
+    //  defer: Deferred,  // defer to resolve/reject at the END of the retries
+    //  attempts: Number  // number of times we've called processFn
+    // }, ...]
+    private readonly queues: Record<string, IQueueEntry<T>[]> = {};
+    private activeQueues: string[] = [];
+    private procFn: ProcessFunction<T> = null;
+
+    constructor(
+        public readonly retryAlgorithm = MatrixScheduler.RETRY_BACKOFF_RATELIMIT,
+        public readonly queueAlgorithm = MatrixScheduler.QUEUE_MESSAGES,
+    ) {}
+
+    /**
+     * Retrieve a queue based on an event. The event provided does not need to be in
+     * the queue.
+     * @param {MatrixEvent} event An event to get the queue for.
+     * @return {?Array<MatrixEvent>} A shallow copy of events in the queue or null.
+     * Modifying this array will not modify the list itself. Modifying events in
+     * this array <i>will</i> modify the underlying event in the queue.
+     * @see MatrixScheduler.removeEventFromQueue To remove an event from the queue.
+     */
+    public getQueueForEvent(event: MatrixEvent): MatrixEvent[] {
+        const name = this.queueAlgorithm(event);
+        if (!name || !this.queues[name]) {
+            return null;
+        }
+        return this.queues[name].map(function(obj) {
+            return obj.event;
+        });
+    }
+
+    /**
+     * Remove this event from the queue. The event is equal to another event if they
+     * have the same ID returned from event.getId().
+     * @param {MatrixEvent} event The event to remove.
+     * @return {boolean} True if this event was removed.
+     */
+    public removeEventFromQueue(event: MatrixEvent): boolean {
+        const name = this.queueAlgorithm(event);
+        if (!name || !this.queues[name]) {
+            return false;
+        }
+        let removed = false;
+        utils.removeElement(this.queues[name], (element) => {
+            if (element.event.getId() === event.getId()) {
+                // XXX we should probably reject the promise?
+                // https://github.com/matrix-org/matrix-js-sdk/issues/496
+                removed = true;
+                return true;
+            }
+        });
+        return removed;
+    }
+
+    /**
+     * Set the process function. Required for events in the queue to be processed.
+     * If set after events have been added to the queue, this will immediately start
+     * processing them.
+     * @param {module:scheduler~processFn} fn The function that can process events
+     * in the queue.
+     */
+    public setProcessFunction(fn: ProcessFunction<T>): void {
+        this.procFn = fn;
+        this.startProcessingQueues();
+    }
+
+    /**
+     * Queue an event if it is required and start processing queues.
+     * @param {MatrixEvent} event The event that may be queued.
+     * @return {?Promise} A promise if the event was queued, which will be
+     * resolved or rejected in due time, else null.
+     */
+    public queueEvent(event: MatrixEvent): Promise<T> | null {
+        const queueName = this.queueAlgorithm(event);
+        if (!queueName) {
+            return null;
+        }
+        // add the event to the queue and make a deferred for it.
+        if (!this.queues[queueName]) {
+            this.queues[queueName] = [];
+        }
+        const defer = utils.defer<T>();
+        this.queues[queueName].push({
+            event: event,
+            defer: defer,
+            attempts: 0,
+        });
+        debuglog("Queue algorithm dumped event %s into queue '%s'", event.getId(), queueName);
+        this.startProcessingQueues();
+        return defer.promise;
+    }
+
+    private startProcessingQueues(): void {
+        if (!this.procFn) return;
+        // for each inactive queue with events in them
+        Object.keys(this.queues)
+            .filter((queueName) => {
+                return this.activeQueues.indexOf(queueName) === -1 &&
+                    this.queues[queueName].length > 0;
+            })
+            .forEach((queueName) => {
+                // mark the queue as active
+                this.activeQueues.push(queueName);
+                // begin processing the head of the queue
+                debuglog("Spinning up queue: '%s'", queueName);
+                this.processQueue(queueName);
+            });
+    }
+
+    private processQueue = (queueName: string): void => {
+        // get head of queue
+        const obj = this.peekNextEvent(queueName);
+        if (!obj) {
+            // queue is empty. Mark as inactive and stop recursing.
+            const index = this.activeQueues.indexOf(queueName);
+            if (index >= 0) {
+                this.activeQueues.splice(index, 1);
+            }
+            debuglog("Stopping queue '%s' as it is now empty", queueName);
+            return;
+        }
+        debuglog("Queue '%s' has %s pending events", queueName, this.queues[queueName].length);
+        // fire the process function and if it resolves, resolve the deferred. Else
+        // invoke the retry algorithm.
+
+        // First wait for a resolved promise, so the resolve handlers for
+        // the deferred of the previously sent event can run.
+        // This way enqueued relations/redactions to enqueued events can receive
+        // the remove id of their target before being sent.
+        Promise.resolve().then(() => {
+            return this.procFn(obj.event);
+        }).then((res) => {
+            // remove this from the queue
+            this.removeNextEvent(queueName);
+            debuglog("Queue '%s' sent event %s", queueName, obj.event.getId());
+            obj.defer.resolve(res);
+            // keep processing
+            this.processQueue(queueName);
+        }, (err) => {
+            obj.attempts += 1;
+            // ask the retry algorithm when/if we should try again
+            const waitTimeMs = this.retryAlgorithm(obj.event, obj.attempts, err);
+            debuglog("retry(%s) err=%s event_id=%s waitTime=%s", obj.attempts, err, obj.event.getId(), waitTimeMs);
+            if (waitTimeMs === -1) {  // give up (you quitter!)
+                debuglog("Queue '%s' giving up on event %s", queueName, obj.event.getId());
+                // remove this from the queue
+                this.removeNextEvent(queueName);
+                obj.defer.reject(err);
+                // process next event
+                this.processQueue(queueName);
+            } else {
+                setTimeout(this.processQueue, waitTimeMs, queueName);
+            }
+        });
+    };
+
+    private peekNextEvent(queueName: string): IQueueEntry<T> {
+        const queue = this.queues[queueName];
+        if (!Array.isArray(queue)) {
+            return null;
+        }
+        return queue[0];
+    }
+
+    private removeNextEvent(queueName: string): IQueueEntry<T> {
+        const queue = this.queues[queueName];
+        if (!Array.isArray(queue)) {
+            return null;
+        }
+        return queue.shift();
+    }
+}
+
+function debuglog(...args) {
+    if (DEBUG) {
+        logger.log(...args);
+    }
+}
+
+/**
+ * The retry algorithm to apply when retrying events. To stop retrying, return
+ * <code>-1</code>. If this event was part of a queue, it will be removed from
+ * the queue.
+ * @callback retryAlgorithm
+ * @param {MatrixEvent} event The event being retried.
+ * @param {Number} attempts The number of failed attempts. This will always be
+ * >= 1.
+ * @param {MatrixError} err The most recent error message received when trying
+ * to send this event.
+ * @return {Number} The number of milliseconds to wait before trying again. If
+ * this is 0, the request will be immediately retried. If this is
+ * <code>-1</code>, the event will be marked as
+ * {@link module:models/event.EventStatus.NOT_SENT} and will not be retried.
+ */
+
+/**
+ * The queuing algorithm to apply to events. This function must be idempotent as
+ * it may be called multiple times with the same event. All queues created are
+ * serviced in a FIFO manner. To send the event ASAP, return <code>null</code>
+ * which will not put this event in a queue. Events that fail to send that form
+ * part of a queue will be removed from the queue and the next event in the
+ * queue will be sent.
+ * @callback queueAlgorithm
+ * @param {MatrixEvent} event The event to be sent.
+ * @return {string} The name of the queue to put the event into. If a queue with
+ * this name does not exist, it will be created. If this is <code>null</code>,
+ * the event is not put into a queue and will be sent concurrently.
+ */
+
+/**
+ * The function to invoke to process (send) events in the queue.
+ * @callback processFn
+ * @param {MatrixEvent} event The event to send.
+ * @return {Promise} Resolved/rejected depending on the outcome of the request.
+ */
+
@@ -15,6 +15,6 @@ limitations under the License.
 */

 export enum SERVICE_TYPES {
-    IS = 'SERVICE_TYPE_IS', // An Identity Service
-    IM = 'SERVICE_TYPE_IM', // An Integration Manager
+    IS = 'SERVICE_TYPE_IS', // An identity server
+    IM = 'SERVICE_TYPE_IM', // An integration manager
 }
@@ -18,10 +18,11 @@ import { EventType } from "../@types/event";
 import { Group } from "../models/group";
 import { Room } from "../models/room";
 import { User } from "../models/user";
-import { MatrixEvent } from "../models/event";
+import { IEvent, MatrixEvent } from "../models/event";
 import { Filter } from "../filter";
 import { RoomSummary } from "../models/room-summary";
-import { IMinimalEvent, IGroups, IRooms } from "../sync-accumulator";
+import { IMinimalEvent, IGroups, IRooms, ISyncResponse } from "../sync-accumulator";
+import { IStartClientOpts } from "../client";

 export interface ISavedSync {
    nextBatch: string;
@@ -35,6 +36,8 @@ export interface ISavedSync {
 * @constructor
 */
 export interface IStore {
+    readonly accountData: Record<string, MatrixEvent>; // type : content
+
    /** @return {Promise<bool>} whether or not the database was newly created in this session. */
    isNewlyCreated(): Promise<boolean>;

@@ -53,6 +56,7 @@ export interface IStore {
    /**
     * No-op.
     * @param {Group} group
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
     */
    storeGroup(group: Group);

@@ -60,12 +64,14 @@ export interface IStore {
     * No-op.
     * @param {string} groupId
     * @return {null}
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
     */
    getGroup(groupId: string): Group | null;

    /**
     * No-op.
     * @return {Array} An empty array.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
     */
    getGroups(): Group[];

@@ -182,7 +188,7 @@ export interface IStore {
     * @param {Object} syncData The sync data
     * @return {Promise} An immediately resolved promise.
     */
-    setSyncData(syncData: object): Promise<void>;
+    setSyncData(syncData: ISyncResponse): Promise<void>;

    /**
     * We never want to save because we have nothing to save to.
@@ -194,7 +200,7 @@ export interface IStore {
    /**
     * Save does nothing as there is no backing data store.
     */
-    save(force: boolean): void;
+    save(force?: boolean): void;

    /**
     * Startup does nothing.
@@ -222,13 +228,13 @@ export interface IStore {
     */
    deleteAllData(): Promise<void>;

-    getOutOfBandMembers(roomId: string): Promise<MatrixEvent[] | null>;
+    getOutOfBandMembers(roomId: string): Promise<IEvent[] | null>;

-    setOutOfBandMembers(roomId: string, membershipEvents: MatrixEvent[]): Promise<void>;
+    setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void>;

    clearOutOfBandMembers(roomId: string): Promise<void>;

-    getClientOptions(): Promise<object>;
+    getClientOptions(): Promise<IStartClientOpts>;

-    storeClientOptions(options: object): Promise<void>;
+    storeClientOptions(options: IStartClientOpts): Promise<void>;
 }
@@ -0,0 +1,36 @@
+/*
+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 { ISavedSync } from "./index";
+import { IEvent, IStartClientOpts, ISyncResponse } from "..";
+
+export interface IIndexedDBBackend {
+    connect(): Promise<void>;
+    syncToDatabase(userTuples: UserTuple[]): Promise<void>;
+    isNewlyCreated(): Promise<boolean>;
+    setSyncData(syncData: ISyncResponse): Promise<void>;
+    getSavedSync(): Promise<ISavedSync>;
+    getNextBatchToken(): Promise<string>;
+    clearDatabase(): Promise<void>;
+    getOutOfBandMembers(roomId: string): Promise<IEvent[] | null>;
+    setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void>;
+    clearOutOfBandMembers(roomId: string): Promise<void>;
+    getUserPresenceEvents(): Promise<UserTuple[]>;
+    getClientOptions(): Promise<IStartClientOpts>;
+    storeClientOptions(options: IStartClientOpts): Promise<void>;
+}
+
+export type UserTuple = [userId: string, presenceEvent: Partial<IEvent>];
@@ -1,7 +1,5 @@
 /*
-Copyright 2017 Vector Creations Ltd
-Copyright 2018 New Vector Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
+Copyright 2017 - 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.
@@ -16,14 +14,17 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { SyncAccumulator } from "../sync-accumulator";
+import { IMinimalEvent, ISyncData, ISyncResponse, SyncAccumulator } from "../sync-accumulator";
 import * as utils from "../utils";
 import * as IndexedDBHelpers from "../indexeddb-helpers";
 import { logger } from '../logger';
+import { IEvent, IStartClientOpts } from "..";
+import { ISavedSync } from "./index";
+import { IIndexedDBBackend, UserTuple } from "./indexeddb-backend";

 const VERSION = 3;

-function createDatabase(db) {
+function createDatabase(db: IDBDatabase): void {
    // Make user store, clobber based on user ID. (userId property of User objects)
    db.createObjectStore("users", { keyPath: ["userId"] });

@@ -35,7 +36,7 @@ function createDatabase(db) {
    db.createObjectStore("sync", { keyPath: ["clobber"] });
 }

-function upgradeSchemaV2(db) {
+function upgradeSchemaV2(db: IDBDatabase): void {
    const oobMembersStore = db.createObjectStore(
        "oob_membership_events", {
            keyPath: ["room_id", "state_key"],
@@ -43,7 +44,7 @@ function upgradeSchemaV2(db) {
    oobMembersStore.createIndex("room", "room_id");
 }

-function upgradeSchemaV3(db) {
+function upgradeSchemaV3(db: IDBDatabase): void {
    db.createObjectStore("client_options",
        { keyPath: ["clobber"] });
 }
@@ -58,16 +59,20 @@ function upgradeSchemaV3(db) {
 * @return {Promise<T[]>} Resolves to an array of whatever you returned from
 * resultMapper.
 */
-function selectQuery(store, keyRange, resultMapper) {
+function selectQuery<T>(
+    store: IDBObjectStore,
+    keyRange: IDBKeyRange | IDBValidKey | undefined,
+    resultMapper: (cursor: IDBCursorWithValue) => T,
+): Promise<T[]> {
    const query = store.openCursor(keyRange);
    return new Promise((resolve, reject) => {
        const results = [];
-        query.onerror = (event) => {
-            reject(new Error("Query failed: " + event.target.errorCode));
+        query.onerror = () => {
+            reject(new Error("Query failed: " + query.error));
        };
        // collect results
-        query.onsuccess = (event) => {
-            const cursor = event.target.result;
+        query.onsuccess = () => {
+            const cursor = query.result;
            if (!cursor) {
                resolve(results);
                return; // end of results
@@ -78,88 +83,84 @@ function selectQuery(store, keyRange, resultMapper) {
    });
 }

-function txnAsPromise(txn) {
+function txnAsPromise(txn: IDBTransaction): Promise<Event> {
    return new Promise((resolve, reject) => {
        txn.oncomplete = function(event) {
            resolve(event);
        };
-        txn.onerror = function(event) {
-            reject(event.target.error);
+        txn.onerror = function() {
+            reject(txn.error);
        };
    });
 }

-function reqAsEventPromise(req) {
+function reqAsEventPromise(req: IDBRequest): Promise<Event> {
    return new Promise((resolve, reject) => {
        req.onsuccess = function(event) {
            resolve(event);
        };
-        req.onerror = function(event) {
-            reject(event.target.error);
+        req.onerror = function() {
+            reject(req.error);
        };
    });
 }

-function reqAsPromise(req) {
+function reqAsPromise(req: IDBRequest): Promise<IDBRequest> {
    return new Promise((resolve, reject) => {
        req.onsuccess = () => resolve(req);
        req.onerror = (err) => reject(err);
    });
 }

-function reqAsCursorPromise(req) {
-    return reqAsEventPromise(req).then((event) => event.target.result);
+function reqAsCursorPromise(req: IDBRequest<IDBCursor | null>): Promise<IDBCursor> {
+    return reqAsEventPromise(req).then((event) => req.result);
 }

-/**
- * Does the actual reading from and writing to the indexeddb
- *
- * Construct a new Indexed Database store backend. This requires a call to
- * <code>connect()</code> before this store can be used.
- * @constructor
- * @param {Object} indexedDBInterface The Indexed DB interface e.g
- * <code>window.indexedDB</code>
- * @param {string=} dbName Optional database name. The same name must be used
- * to open the same database.
- */
-export function LocalIndexedDBStoreBackend(
-    indexedDBInterface, dbName,
-) {
-    this.indexedDB = indexedDBInterface;
-    this._dbName = "matrix-js-sdk:" + (dbName || "default");
-    this.db = null;
-    this._disconnected = true;
-    this._syncAccumulator = new SyncAccumulator();
-    this._isNewlyCreated = false;
-}
+export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
+    public static exists(indexedDB: IDBFactory, dbName: string): Promise<boolean> {
+        dbName = "matrix-js-sdk:" + (dbName || "default");
+        return IndexedDBHelpers.exists(indexedDB, dbName);
+    }

-LocalIndexedDBStoreBackend.exists = function(indexedDB, dbName) {
-    dbName = "matrix-js-sdk:" + (dbName || "default");
-    return IndexedDBHelpers.exists(indexedDB, dbName);
-};
+    private readonly dbName: string;
+    private readonly syncAccumulator: SyncAccumulator;
+    private db: IDBDatabase = null;
+    private disconnected = true;
+    private _isNewlyCreated = false;
+
+    /**
+     * Does the actual reading from and writing to the indexeddb
+     *
+     * Construct a new Indexed Database store backend. This requires a call to
+     * <code>connect()</code> before this store can be used.
+     * @constructor
+     * @param {Object} indexedDB The Indexed DB interface e.g
+     * <code>window.indexedDB</code>
+     * @param {string=} dbName Optional database name. The same name must be used
+     * to open the same database.
+     */
+    constructor(private readonly indexedDB: IDBFactory, dbName: string) {
+        this.dbName = "matrix-js-sdk:" + (dbName || "default");
+        this.syncAccumulator = new SyncAccumulator();
+    }

-LocalIndexedDBStoreBackend.prototype = {
    /**
     * Attempt to connect to the database. This can fail if the user does not
     * grant permission.
     * @return {Promise} Resolves if successfully connected.
     */
-    connect: function() {
-        if (!this._disconnected) {
-            logger.log(
-                `LocalIndexedDBStoreBackend.connect: already connected or connecting`,
-            );
+    public connect(): Promise<void> {
+        if (!this.disconnected) {
+            logger.log(`LocalIndexedDBStoreBackend.connect: already connected or connecting`);
            return Promise.resolve();
        }

-        this._disconnected = false;
+        this.disconnected = false;

-        logger.log(
-            `LocalIndexedDBStoreBackend.connect: connecting...`,
-        );
-        const req = this.indexedDB.open(this._dbName, VERSION);
+        logger.log(`LocalIndexedDBStoreBackend.connect: connecting...`);
+        const req = this.indexedDB.open(this.dbName, VERSION);
        req.onupgradeneeded = (ev) => {
-            const db = ev.target.result;
+            const db = req.result;
            const oldVersion = ev.oldVersion;
            logger.log(
                `LocalIndexedDBStoreBackend.connect: upgrading from ${oldVersion}`,
@@ -178,19 +179,13 @@ LocalIndexedDBStoreBackend.prototype = {
        };

        req.onblocked = () => {
-            logger.log(
-                `can't yet open LocalIndexedDBStoreBackend because it is open elsewhere`,
-            );
+            logger.log(`can't yet open LocalIndexedDBStoreBackend because it is open elsewhere`);
        };

-        logger.log(
-            `LocalIndexedDBStoreBackend.connect: awaiting connection...`,
-        );
-        return reqAsEventPromise(req).then((ev) => {
-            logger.log(
-                `LocalIndexedDBStoreBackend.connect: connected`,
-            );
-            this.db = ev.target.result;
+        logger.log(`LocalIndexedDBStoreBackend.connect: awaiting connection...`);
+        return reqAsEventPromise(req).then(() => {
+            logger.log(`LocalIndexedDBStoreBackend.connect: connected`);
+            this.db = req.result;

            // add a poorly-named listener for when deleteDatabase is called
            // so we can close our db connections.
@@ -198,27 +193,26 @@ LocalIndexedDBStoreBackend.prototype = {
                this.db.close();
            };

-            return this._init();
+            return this.init();
        });
-    },
-    /** @return {bool} whether or not the database was newly created in this session. */
-    isNewlyCreated: function() {
+    }
+
+    /** @return {boolean} whether or not the database was newly created in this session. */
+    public isNewlyCreated(): Promise<boolean> {
        return Promise.resolve(this._isNewlyCreated);
-    },
+    }

    /**
     * Having connected, load initial data from the database and prepare for use
     * @return {Promise} Resolves on success
     */
-    _init: function() {
+    private init() {
        return Promise.all([
-            this._loadAccountData(),
-            this._loadSyncData(),
+            this.loadAccountData(),
+            this.loadSyncData(),
        ]).then(([accountData, syncData]) => {
-            logger.log(
-                `LocalIndexedDBStoreBackend: loaded initial data`,
-            );
-            this._syncAccumulator.accumulate({
+            logger.log(`LocalIndexedDBStoreBackend: loaded initial data`);
+            this.syncAccumulator.accumulate({
                next_batch: syncData.nextBatch,
                rooms: syncData.roomsData,
                groups: syncData.groupsData,
@@ -227,7 +221,7 @@ LocalIndexedDBStoreBackend.prototype = {
                },
            }, true);
        });
-    },
+    }

    /**
     * Returns the out-of-band membership events for this room that
@@ -236,8 +230,8 @@ LocalIndexedDBStoreBackend.prototype = {
     * @returns {Promise<event[]>} the events, potentially an empty array if OOB loading didn't yield any new members
     * @returns {null} in case the members for this room haven't been stored yet
     */
-    getOutOfBandMembers: function(roomId) {
-        return new Promise((resolve, reject) =>{
+    public getOutOfBandMembers(roomId: string): Promise<IEvent[] | null> {
+        return new Promise<IEvent[] | null>((resolve, reject) =>{
            const tx = this.db.transaction(["oob_membership_events"], "readonly");
            const store = tx.objectStore("oob_membership_events");
            const roomIndex = store.index("room");
@@ -252,8 +246,8 @@ LocalIndexedDBStoreBackend.prototype = {
            // were all known already
            let oobWritten = false;

-            request.onsuccess = (event) => {
-                const cursor = event.target.result;
+            request.onsuccess = () => {
+                const cursor = request.result;
                if (!cursor) {
                    // Unknown room
                    if (!membershipEvents.length && !oobWritten) {
@@ -273,11 +267,10 @@ LocalIndexedDBStoreBackend.prototype = {
                reject(err);
            };
        }).then((events) => {
-            logger.log(`LL: got ${events && events.length}` +
-                ` membershipEvents from storage for room ${roomId} ...`);
+            logger.log(`LL: got ${events && events.length} membershipEvents from storage for room ${roomId} ...`);
            return events;
        });
-    },
+    }

    /**
     * Stores the out-of-band membership events for this room. Note that
@@ -286,7 +279,7 @@ LocalIndexedDBStoreBackend.prototype = {
     * @param {string} roomId
     * @param {event[]} membershipEvents the membership events to store
     */
-    setOutOfBandMembers: async function(roomId, membershipEvents) {
+    public async setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void> {
        logger.log(`LL: backend about to store ${membershipEvents.length}` +
            ` members for ${roomId}`);
        const tx = this.db.transaction(["oob_membership_events"], "readwrite");
@@ -307,9 +300,9 @@ LocalIndexedDBStoreBackend.prototype = {
        store.put(markerObject);
        await txnAsPromise(tx);
        logger.log(`LL: backend done storing for ${roomId}!`);
-    },
+    }

-    clearOutOfBandMembers: async function(roomId) {
+    public async clearOutOfBandMembers(roomId: string): Promise<void> {
        // the approach to delete all members for a room
        // is to get the min and max state key from the index
        // for that room, and then delete between those
@@ -324,11 +317,11 @@ LocalIndexedDBStoreBackend.prototype = {
        const roomRange = IDBKeyRange.only(roomId);

        const minStateKeyProm = reqAsCursorPromise(
-                roomIndex.openKeyCursor(roomRange, "next"),
-            ).then((cursor) => cursor && cursor.primaryKey[1]);
+            roomIndex.openKeyCursor(roomRange, "next"),
+        ).then((cursor) => cursor && cursor.primaryKey[1]);
        const maxStateKeyProm = reqAsCursorPromise(
-                roomIndex.openKeyCursor(roomRange, "prev"),
-            ).then((cursor) => cursor && cursor.primaryKey[1]);
+            roomIndex.openKeyCursor(roomRange, "prev"),
+        ).then((cursor) => cursor && cursor.primaryKey[1]);
        const [minStateKey, maxStateKey] = await Promise.all(
            [minStateKeyProm, maxStateKeyProm]);

@@ -341,45 +334,39 @@ LocalIndexedDBStoreBackend.prototype = {
            [roomId, maxStateKey],
        );

-        logger.log(`LL: Deleting all users + marker in storage for ` +
-            `room ${roomId}, with key range:`,
+        logger.log(`LL: Deleting all users + marker in storage for room ${roomId}, with key range:`,
            [roomId, minStateKey], [roomId, maxStateKey]);
        await reqAsPromise(writeStore.delete(membersKeyRange));
-    },
+    }

    /**
     * Clear the entire database. This should be used when logging out of a client
     * to prevent mixing data between accounts.
     * @return {Promise} Resolved when the database is cleared.
     */
-    clearDatabase: function() {
-        return new Promise((resolve, reject) => {
-            logger.log(`Removing indexeddb instance: ${this._dbName}`);
-            const req = this.indexedDB.deleteDatabase(this._dbName);
+    public clearDatabase(): Promise<void> {
+        return new Promise((resolve) => {
+            logger.log(`Removing indexeddb instance: ${this.dbName}`);
+            const req = this.indexedDB.deleteDatabase(this.dbName);

            req.onblocked = () => {
-                logger.log(
-                    `can't yet delete indexeddb ${this._dbName}` +
-                    ` because it is open elsewhere`,
-                );
+                logger.log(`can't yet delete indexeddb ${this.dbName} because it is open elsewhere`);
            };

-            req.onerror = (ev) => {
+            req.onerror = () => {
                // in firefox, with indexedDB disabled, this fails with a
                // DOMError. We treat this as non-fatal, so that we can still
                // use the app.
-                logger.warn(
-                    `unable to delete js-sdk store indexeddb: ${ev.target.error}`,
-                );
+                logger.warn(`unable to delete js-sdk store indexeddb: ${req.error}`);
                resolve();
            };

            req.onsuccess = () => {
-                logger.log(`Removed indexeddb instance: ${this._dbName}`);
+                logger.log(`Removed indexeddb instance: ${this.dbName}`);
                resolve();
            };
        });
-    },
+    }

    /**
     * @param {boolean=} copy If false, the data returned is from internal
@@ -390,10 +377,8 @@ LocalIndexedDBStoreBackend.prototype = {
     * client state to where it was at the last save, or null if there
     * is no saved sync data.
     */
-    getSavedSync: function(copy) {
-        if (copy === undefined) copy = true;
-
-        const data = this._syncAccumulator.getJSON();
+    public getSavedSync(copy = true): Promise<ISavedSync> {
+        const data = this.syncAccumulator.getJSON();
        if (!data.nextBatch) return Promise.resolve(null);
        if (copy) {
            // We must deep copy the stored data so that the /sync processing code doesn't
@@ -402,29 +387,27 @@ LocalIndexedDBStoreBackend.prototype = {
        } else {
            return Promise.resolve(data);
        }
-    },
+    }

-    getNextBatchToken: function() {
-        return Promise.resolve(this._syncAccumulator.getNextBatchToken());
-    },
+    public getNextBatchToken(): Promise<string> {
+        return Promise.resolve(this.syncAccumulator.getNextBatchToken());
+    }

-    setSyncData: function(syncData) {
+    public setSyncData(syncData: ISyncResponse): Promise<void> {
        return Promise.resolve().then(() => {
-            this._syncAccumulator.accumulate(syncData);
+            this.syncAccumulator.accumulate(syncData);
        });
-    },
+    }

-    syncToDatabase: function(userTuples) {
-        const syncData = this._syncAccumulator.getJSON(true);
+    public async syncToDatabase(userTuples: UserTuple[]): Promise<void> {
+        const syncData = this.syncAccumulator.getJSON(true);

-        return Promise.all([
-            this._persistUserPresenceEvents(userTuples),
-            this._persistAccountData(syncData.accountData),
-            this._persistSyncData(
-                syncData.nextBatch, syncData.roomsData, syncData.groupsData,
-            ),
+        await Promise.all([
+            this.persistUserPresenceEvents(userTuples),
+            this.persistAccountData(syncData.accountData),
+            this.persistSyncData(syncData.nextBatch, syncData.roomsData, syncData.groupsData),
        ]);
-    },
+    }

    /**
     * Persist rooms /sync data along with the next batch token.
@@ -433,20 +416,24 @@ LocalIndexedDBStoreBackend.prototype = {
     * @param {Object} groupsData The 'groups' /sync data from a SyncAccumulator
     * @return {Promise} Resolves if the data was persisted.
     */
-    _persistSyncData: function(nextBatch, roomsData, groupsData) {
+    private persistSyncData(
+        nextBatch: string,
+        roomsData: ISyncResponse["rooms"],
+        groupsData: ISyncResponse["groups"],
+    ): Promise<void> {
        logger.log("Persisting sync data up to", nextBatch);
-        return utils.promiseTry(() => {
+        return utils.promiseTry<void>(() => {
            const txn = this.db.transaction(["sync"], "readwrite");
            const store = txn.objectStore("sync");
            store.put({
                clobber: "-", // constant key so will always clobber
-                nextBatch: nextBatch,
-                roomsData: roomsData,
-                groupsData: groupsData,
+                nextBatch,
+                roomsData,
+                groupsData,
            }); // put == UPSERT
-            return txnAsPromise(txn);
+            return txnAsPromise(txn).then();
        });
-    },
+    }

    /**
     * Persist a list of account data events. Events with the same 'type' will
@@ -454,16 +441,16 @@ LocalIndexedDBStoreBackend.prototype = {
     * @param {Object[]} accountData An array of raw user-scoped account data events
     * @return {Promise} Resolves if the events were persisted.
     */
-    _persistAccountData: function(accountData) {
-        return utils.promiseTry(() => {
+    private persistAccountData(accountData: IMinimalEvent[]): Promise<void> {
+        return utils.promiseTry<void>(() => {
            const txn = this.db.transaction(["accountData"], "readwrite");
            const store = txn.objectStore("accountData");
            for (let i = 0; i < accountData.length; i++) {
                store.put(accountData[i]); // put == UPSERT
            }
-            return txnAsPromise(txn);
+            return txnAsPromise(txn).then();
        });
-    },
+    }

    /**
     * Persist a list of [user id, presence event] they are for.
@@ -473,8 +460,8 @@ LocalIndexedDBStoreBackend.prototype = {
     * @param {Object[]} tuples An array of [userid, event] tuples
     * @return {Promise} Resolves if the users were persisted.
     */
-    _persistUserPresenceEvents: function(tuples) {
-        return utils.promiseTry(() => {
+    private persistUserPresenceEvents(tuples: UserTuple[]): Promise<void> {
+        return utils.promiseTry<void>(() => {
            const txn = this.db.transaction(["users"], "readwrite");
            const store = txn.objectStore("users");
            for (const tuple of tuples) {
@@ -483,9 +470,9 @@ LocalIndexedDBStoreBackend.prototype = {
                    event: tuple[1],
                }); // put == UPSERT
            }
-            return txnAsPromise(txn);
+            return txnAsPromise(txn).then();
        });
-    },
+    }

    /**
     * Load all user presence events from the database. This is not cached.
@@ -493,64 +480,56 @@ LocalIndexedDBStoreBackend.prototype = {
     * sync.
     * @return {Promise<Object[]>} A list of presence events in their raw form.
     */
-    getUserPresenceEvents: function() {
-        return utils.promiseTry(() => {
+    public getUserPresenceEvents(): Promise<UserTuple[]> {
+        return utils.promiseTry<UserTuple[]>(() => {
            const txn = this.db.transaction(["users"], "readonly");
            const store = txn.objectStore("users");
            return selectQuery(store, undefined, (cursor) => {
                return [cursor.value.userId, cursor.value.event];
            });
        });
-    },
+    }

    /**
     * Load all the account data events from the database. This is not cached.
     * @return {Promise<Object[]>} A list of raw global account events.
     */
-    _loadAccountData: function() {
-        logger.log(
-            `LocalIndexedDBStoreBackend: loading account data...`,
-        );
-        return utils.promiseTry(() => {
+    private loadAccountData(): Promise<IMinimalEvent[]> {
+        logger.log(`LocalIndexedDBStoreBackend: loading account data...`);
+        return utils.promiseTry<IMinimalEvent[]>(() => {
            const txn = this.db.transaction(["accountData"], "readonly");
            const store = txn.objectStore("accountData");
            return selectQuery(store, undefined, (cursor) => {
                return cursor.value;
-            }).then((result) => {
-                logger.log(
-                    `LocalIndexedDBStoreBackend: loaded account data`,
-                );
+            }).then((result: IMinimalEvent[]) => {
+                logger.log(`LocalIndexedDBStoreBackend: loaded account data`);
                return result;
            });
        });
-    },
+    }

    /**
     * Load the sync data from the database.
     * @return {Promise<Object>} An object with "roomsData" and "nextBatch" keys.
     */
-    _loadSyncData: function() {
-        logger.log(
-            `LocalIndexedDBStoreBackend: loading sync data...`,
-        );
-        return utils.promiseTry(() => {
+    private loadSyncData(): Promise<ISyncData> {
+        logger.log(`LocalIndexedDBStoreBackend: loading sync data...`);
+        return utils.promiseTry<ISyncData>(() => {
            const txn = this.db.transaction(["sync"], "readonly");
            const store = txn.objectStore("sync");
            return selectQuery(store, undefined, (cursor) => {
                return cursor.value;
-            }).then((results) => {
-                logger.log(
-                    `LocalIndexedDBStoreBackend: loaded sync data`,
-                );
+            }).then((results: ISyncData[]) => {
+                logger.log(`LocalIndexedDBStoreBackend: loaded sync data`);
                if (results.length > 1) {
                    logger.warn("loadSyncData: More than 1 sync row found.");
                }
-                return (results.length > 0 ? results[0] : {});
+                return results.length > 0 ? results[0] : {} as ISyncData;
            });
        });
-    },
+    }

-    getClientOptions: function() {
+    public getClientOptions(): Promise<IStartClientOpts> {
        return Promise.resolve().then(() => {
            const txn = this.db.transaction(["client_options"], "readonly");
            const store = txn.objectStore("client_options");
@@ -560,9 +539,9 @@ LocalIndexedDBStoreBackend.prototype = {
                }
            }).then((results) => results[0]);
        });
-    },
+    }

-    storeClientOptions: async function(options) {
+    public async storeClientOptions(options: IStartClientOpts): Promise<void> {
        const txn = this.db.transaction(["client_options"], "readwrite");
        const store = txn.objectStore("client_options");
        store.put({
@@ -570,5 +549,5 @@ LocalIndexedDBStoreBackend.prototype = {
            options: options,
        }); // put == UPSERT
        await txnAsPromise(txn);
-    },
-};
+    }
+}
--- a/Show More
+++ b/Show More