v37.3.0

v37.3.0-rc.0
Update dependency matrix-widget-api to v1.13.1 (#4689 )
2025-04-08 12:37:43 +00:00 · 2025-04-01 12:28:09 +00:00 · 2025-03-31 12:52:27 +00:00 · 2025-03-25 14:42:58 +00:00 · 2025-03-25 14:42:20 +00:00 · 2025-03-25 12:49:47 +00:00
341 changed files with 7191 additions and 35077 deletions
@@ -86,12 +86,11 @@ module.exports = {
        // Disabled tests are a reality for now but as soon as all of the xits are
        // eliminated, we should enforce this.
        "jest/no-disabled-tests": "off",
-        // Also treat "oldBackendOnly" as a test function.
        // Used in some crypto tests.
        "jest/no-standalone-expect": [
            "error",
            {
-                additionalTestBlockFunctions: ["beforeAll", "beforeEach", "oldBackendOnly", "newBackendOnly"],
+                additionalTestBlockFunctions: ["beforeAll", "beforeEach"],
            },
        ],
    },
@@ -112,8 +111,13 @@ module.exports = {
                "@typescript-eslint/ban-ts-comment": "off",
                // We're okay with assertion errors when we ask for them
                "@typescript-eslint/no-non-null-assertion": "off",
-                // We do this sometimes to brand interfaces
-                "@typescript-eslint/no-empty-object-type": "off",
+                "@typescript-eslint/no-empty-object-type": [
+                    "error",
+                    {
+                        // We do this sometimes to brand interfaces
+                        allowInterfaces: "with-single-extends",
+                    },
+                ],

                "quotes": "off",
                // We use a `logger` intermediary module
@@ -147,6 +151,18 @@ module.exports = {
                // We don't need super strict typing in test utilities
                "@typescript-eslint/explicit-function-return-type": "off",
                "@typescript-eslint/explicit-member-accessibility": "off",
+                "@typescript-eslint/no-empty-object-type": "off",
+            },
+        },
+        {
+            // Enable stricter promise rules for the MatrixRTC codebase
+            files: ["src/matrixrtc/**/*.ts", "spec/unit/matrixrtc/*.ts"],
+            rules: {
+                // Encourage proper usage of Promises:
+                "@typescript-eslint/no-floating-promises": "error",
+                "@typescript-eslint/no-misused-promises": "error",
+                "@typescript-eslint/require-await": "error",
+                "@typescript-eslint/await-thenable": "error",
            },
        },
    ],
@@ -279,6 +279,9 @@ jobs:
        needs: release
        if: inputs.npm
        uses: matrix-org/matrix-js-sdk/.github/workflows/release-npm.yml@develop
+        permissions:
+            contents: read
+            id-token: write
        secrets:
            NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

@@ -8,11 +8,14 @@ on:
            id:
                description: "The npm package@version string we published"
                value: ${{ jobs.npm.outputs.id }}
-permissions: {} # No permissions required
+permissions: {}
 jobs:
    npm:
        name: Publish to npm
        runs-on: ubuntu-24.04
+        permissions:
+            contents: read
+            id-token: write
        outputs:
            id: ${{ steps.npm-publish.outputs.id }}
        steps:
@@ -33,16 +36,12 @@ jobs:

            - name: 🚀 Publish to npm
              id: npm-publish
-              uses: JS-DevTools/npm-publish@19c28f1ef146469e409470805ea4279d47c3d35c # v3.1.1
-              with:
-                  token: ${{ secrets.NPM_TOKEN }}
-                  access: public
-                  tag: next
-                  ignore-scripts: false
-
-            - name: Check npm package was published
-              if: steps.npm-publish.outputs.id == ''
-              run: exit 1
+              run: |
+                  npm publish --provenance --access public --tag next
+                  release=$(jq -r '"\(.name)@\(.version)"' package.json)
+                  echo "id=$release" >> $GITHUB_OUTPUT
+              env:
+                  NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

            - name: 🎖️ Add `latest` dist-tag to final releases
              if: steps.npm-publish.outputs.id && !contains(steps.npm-publish.outputs.id, '-rc.')
@@ -29,6 +29,7 @@ jobs:
            contents: write
            issues: write
            pull-requests: read
+            id-token: write
        secrets: inherit
        with:
            final: ${{ inputs.mode == 'final' }}
@@ -27,7 +27,7 @@ jobs:
        steps:
            # We create the status here and then update it to success/failure in the `report` stage
            # This provides an easy link to this workflow_run from the PR before Sonarcloud is done.
-            - uses: guibranco/github-status-action-v2@ecd54a02cf761e85a8fb328fe937710fd4227cda
+            - uses: guibranco/github-status-action-v2@fe98467f9071758c7fc214af9dbac7f301bd23d4
              with:
                  authToken: ${{ secrets.GITHUB_TOKEN }}
                  state: pending
@@ -75,7 +75,7 @@ jobs:

            - name: "🩻 SonarCloud Scan"
              id: sonarcloud
-              uses: matrix-org/sonarcloud-workflow-action@v3.3
+              uses: matrix-org/sonarcloud-workflow-action@v4.0
              # workflow_run fails report against the develop commit always, we don't want that for PRs
              continue-on-error: ${{ github.event.workflow_run.head_branch != 'develop' }}
              with:
@@ -87,7 +87,7 @@ jobs:
                  revision: ${{ github.event.workflow_run.head_sha }}
                  token: ${{ secrets.SONAR_TOKEN }}

-            - uses: guibranco/github-status-action-v2@ecd54a02cf761e85a8fb328fe937710fd4227cda
+            - uses: guibranco/github-status-action-v2@fe98467f9071758c7fc214af9dbac7f301bd23d4
              if: always()
              with:
                  authToken: ${{ secrets.GITHUB_TOKEN }}
@@ -116,7 +116,7 @@ jobs:
        steps:
            - name: Skip SonarCloud on merge queues
              if: env.ENABLE_COVERAGE == 'false'
-              uses: guibranco/github-status-action-v2@ecd54a02cf761e85a8fb328fe937710fd4227cda
+              uses: guibranco/github-status-action-v2@fe98467f9071758c7fc214af9dbac7f301bd23d4
              with:
                  authToken: ${{ secrets.GITHUB_TOKEN }}
                  state: success
@@ -0,0 +1,22 @@
+name: Close stale PRs
+on:
+    workflow_dispatch: {}
+    schedule:
+        - cron: "30 1 * * *"
+permissions: {}
+jobs:
+    close:
+        runs-on: ubuntu-24.04
+        permissions:
+            actions: write
+            issues: write
+            pull-requests: write
+        steps:
+            - uses: actions/stale@v9
+              with:
+                  operations-per-run: 250
+                  days-before-issue-stale: -1
+                  days-before-issue-close: -1
+                  days-before-pr-stale: 180
+                  days-before-pr-close: 0
+                  close-pr-message: "This PR has been automatically closed because it has been stale for 180 days. If you wish to continue working on this PR, please ping a maintainer to reopen it."
@@ -1,3 +1,95 @@
+Changes in [37.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v37.3.0) (2025-04-08)
+==================================================================================================
+## ✨ Features
+
+* MatrixRTC MembershipManger: remove redundant sendDelayedEventAction and expose status ([#4747](https://github.com/matrix-org/matrix-js-sdk/pull/4747)). Contributed by @toger5.
+* Abstract logout-causing error type from tokenRefreshFunction calls ([#4765](https://github.com/matrix-org/matrix-js-sdk/pull/4765)). Contributed by @t3chguy.
+* Improve PushProcessor::getPushRuleGlobRegex ([#4764](https://github.com/matrix-org/matrix-js-sdk/pull/4764)). Contributed by @t3chguy.
+* Export push processor \& method for converting matrix glob to regexp ([#4763](https://github.com/matrix-org/matrix-js-sdk/pull/4763)). Contributed by @t3chguy.
+* Add authenticated media parameter to getMediaConfig ([#4762](https://github.com/matrix-org/matrix-js-sdk/pull/4762)). Contributed by @m004.
+* Rust crypto: set a timeout on outgoing HTTP requests ([#4761](https://github.com/matrix-org/matrix-js-sdk/pull/4761)). Contributed by @richvdh.
+* Switch sliding sync support to simplified sliding sync ([#4400](https://github.com/matrix-org/matrix-js-sdk/pull/4400)). Contributed by @dbkr.
+
+
+Changes in [37.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v37.2.0) (2025-03-25)
+==================================================================================================
+## ✨ Features
+
+* Add reportRoom API ([#4753](https://github.com/matrix-org/matrix-js-sdk/pull/4753)). Contributed by @Half-Shot.
+* MatrixRTC: New membership manager ([#4726](https://github.com/matrix-org/matrix-js-sdk/pull/4726)). Contributed by @toger5.
+* Add disableKeyStorage() to crypto API ([#4742](https://github.com/matrix-org/matrix-js-sdk/pull/4742)). Contributed by @dbkr.
+
+## 🐛 Bug Fixes
+
+* Allow port differing in OIDC dynamic registration URIs ([#4749](https://github.com/matrix-org/matrix-js-sdk/pull/4749)). Contributed by @t3chguy.
+* OIDC: only pass logo\_uri, policy\_uri, tos\_uri if they conform to "common base" ([#4748](https://github.com/matrix-org/matrix-js-sdk/pull/4748)). Contributed by @t3chguy.
+
+
+Changes in [37.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v37.1.0) (2025-03-11)
+==================================================================================================
+## 🦖 Deprecations
+
+* MatrixRTC: MembershipManager test cases and deprecation of MatrixRTCSession.room ([#4713](https://github.com/matrix-org/matrix-js-sdk/pull/4713)). Contributed by @toger5.
+
+## ✨ Features
+
+* Add `EventType.SecretRequest` and `EventType.SecretSend` ([#4728](https://github.com/matrix-org/matrix-js-sdk/pull/4728)). Contributed by @richvdh.
+* Attest npm package provenance ([#4724](https://github.com/matrix-org/matrix-js-sdk/pull/4724)). Contributed by @t3chguy.
+* Report backup key import progress on start and improve types ([#4711](https://github.com/matrix-org/matrix-js-sdk/pull/4711)). Contributed by @ajbura.
+
+## 🐛 Bug Fixes
+
+* Handle unexpected token refresh failures gracefully ([#4731](https://github.com/matrix-org/matrix-js-sdk/pull/4731)). Contributed by @t3chguy.
+* Fix idempotency issue around token refresh ([#4730](https://github.com/matrix-org/matrix-js-sdk/pull/4730)). Contributed by @t3chguy.
+* Delete the dehydrated device when resetEncryption is called ([#4727](https://github.com/matrix-org/matrix-js-sdk/pull/4727)). Contributed by @uhoreg.
+
+
+Changes in [37.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v37.0.0) (2025-02-25)
+==================================================================================================
+## 🚨 BREAKING CHANGES
+
+* Remove deprecated `PrefixedLogger` interface ([#4705](https://github.com/matrix-org/matrix-js-sdk/pull/4705)). Contributed by @richvdh.
+* Remove legacy crypto ([#4653](https://github.com/matrix-org/matrix-js-sdk/pull/4653)). Contributed by @florianduros.
+
+## 🦖 Deprecations
+
+* Improve types around User Interactive Auth ([#4709](https://github.com/matrix-org/matrix-js-sdk/pull/4709)). Contributed by @t3chguy.
+
+## ✨ Features
+
+* Fix typos in client.ts ([#4715](https://github.com/matrix-org/matrix-js-sdk/pull/4715)). Contributed by @toger5.
+* Enable key upload to backups where we have the decryption key ([#4677](https://github.com/matrix-org/matrix-js-sdk/pull/4677)). Contributed by @ajbura.
+* Remove deprecated `PrefixedLogger` interface ([#4705](https://github.com/matrix-org/matrix-js-sdk/pull/4705)). Contributed by @richvdh.
+* `MatrixClient.setAccountData`: await remote echo. ([#4695](https://github.com/matrix-org/matrix-js-sdk/pull/4695)). Contributed by @richvdh.
+
+## 🐛 Bug Fixes
+
+* Improve types around User Interactive Auth ([#4709](https://github.com/matrix-org/matrix-js-sdk/pull/4709)). Contributed by @t3chguy.
+* Fix `resetEncryption` to remove secrets in 4S ([#4683](https://github.com/matrix-org/matrix-js-sdk/pull/4683)). Contributed by @florianduros.
+
+
+Changes in [36.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v36.2.0) (2025-02-11)
+==================================================================================================
+## 🦖 Deprecations
+
+* [Backport staging] Deprecate parameter and functions using legacy crypto in `models/event.ts` ([#4700](https://github.com/matrix-org/matrix-js-sdk/pull/4700)). Contributed by @RiotRobot.
+
+## ✨ Features
+
+* Improve types around Terms ([#4674](https://github.com/matrix-org/matrix-js-sdk/pull/4674)). Contributed by @t3chguy.
+* Provide more options for starting dehydration ([#4664](https://github.com/matrix-org/matrix-js-sdk/pull/4664)). Contributed by @uhoreg.
+* Device Dehydration | js-sdk: store/load dehydration key ([#4599](https://github.com/matrix-org/matrix-js-sdk/pull/4599)). Contributed by @BillCarsonFr.
+* Add unspecced backup disable flag ([#4661](https://github.com/matrix-org/matrix-js-sdk/pull/4661)). Contributed by @dbkr.
+* Switch OIDC primarily to new `/auth_metadata` API ([#4626](https://github.com/matrix-org/matrix-js-sdk/pull/4626)). Contributed by @t3chguy.
+* Add `CryptoApi.resetEncryption` ([#4614](https://github.com/matrix-org/matrix-js-sdk/pull/4614)). Contributed by @florianduros.
+
+## 🐛 Bug Fixes
+
+* Fix topic types ([#4678](https://github.com/matrix-org/matrix-js-sdk/pull/4678)). Contributed by @Half-Shot.
+* Handle empty m.room.topic ([#4673](https://github.com/matrix-org/matrix-js-sdk/pull/4673)). Contributed by @Half-Shot.
+* `CryptoApi.resetEncryption` should always create a new key backup ([#4648](https://github.com/matrix-org/matrix-js-sdk/pull/4648)). Contributed by @florianduros.
+
+
 Changes in [36.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v36.1.0) (2025-01-28)
 ==================================================================================================
 ## ✨ Features
@@ -1,3 +1,241 @@
 # Contributing code to matrix-js-sdk

-matrix-js-sdk follows the same pattern as https://github.com/vector-im/element-web/blob/develop/CONTRIBUTING.md
+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.
+
+Your PR should have a title that describes what change is being made. This
+is used for the text in the Changelog entry by default (see below), so a good
+title will tell a user succinctly what change is being made. "Fix bug where
+cows had five legs" and, "Add support for miniature horses" are examples of good
+titles. Don't include an issue number here: that belongs in the description.
+Definitely don't use the GitHub default of "Update file.ts".
+
+As for your PR description, it should include these things:
+
+- 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. This information is
+  also helpful when we come back to look at this in 6 months and ask "why did
+  we do it like that?" we have a chance of finding out.
+    - Why didn't it work before? Why does it work now? What use cases does it
+      unlock?
+    - If you find yourself adding information on how the code works or why you
+      chose to do it the way you did, make sure this information is instead
+      written as comments in the code itself.
+    - Sometimes a PR can change considerably as it is developed. In this case,
+      the description should be updated to reflect the most recent state of
+      the PR. (It can be helpful to retain the old content under a suitable
+      heading, for additional context.)
+- 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.
+
+### Changelogs
+
+There's no need to manually add Changelog entries: we use information in the
+pull request to populate the information that goes into the changelogs our
+users see, both for Element Web itself and other projects on which it is based.
+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:
+
+- 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
+
+Your PR should include tests.
+
+For new user facing features in `matrix-js-sdk`, you
+must include comprehensive unit tests written in Jest.
+The existing tests can be found under `spec/unit`
+
+It's good practice to write tests alongside the code as it ensures the code is testable from
+the start, and gives you a fast feedback loop while you're developing the
+functionality. Unit tests are necessary even for bug fixes.
+
+When writing unit tests, please aim for a high level of test coverage
+for new code - 80% or greater. If you cannot achieve that, please document
+why it's not possible in your PR.
+
+Tests validate that your change works as intended and also document
+concisely what is being changed. Ideally, your new tests fail
+prior to your change, and succeed once it has been applied. You may
+find this simpler to achieve if you write the tests first.
+
+If you're spiking some code that's experimental and not being used to support
+production features, exceptions can be made to requirements for tests.
+Note that tests will still be required in order to ship the feature, and it's
+strongly encouraged to think about tests early in the process, as adding
+tests later will become progressively more difficult.
+
+If you're not sure how to approach writing tests for your change, ask for help
+in [#element-dev](https://matrix.to/#/#element-dev:matrix.org).
+
+## Code style
+
+Code style is documented in [code_style.md](./code_style.md).
+Contributors are encouraged to it 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.
+
+## 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/html/latest/process/submitting-patches.html), 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
+```
+
+# Review expectations
+
+See https://github.com/vector-im/element-meta/wiki/Review-process
+
+# Merge Strategy
+
+The preferred method for merging pull requests is squash merging to keep the
+commit history trim, but it is up to the discretion of the team member merging
+the change. We do not support rebase merges due to `allchange` being unable to
+handle them. When merging make sure to leave the default commit title, or
+at least leave the PR number at the end in brackets like by default.
+When stacking pull requests, you may wish to do the following:
+
+1. Branch from develop to your branch (branch1), push commits onto it and open a pull request
+2. Branch from your base branch (branch1) to your work branch (branch2), push commits and open a pull request configuring the base to be branch1, saying in the description that it is based on your other PR.
+3. Merge the first PR using a merge commit otherwise your stacked PR will need a rebase. Github will automatically adjust the base branch of your other PR to be develop.
@@ -154,7 +154,7 @@ events for incoming data and state changes. Aside from wrapping the HTTP API, it
 `matrix-js-sdk` can be used in either Node.js applications (ensure you have the latest LTS version of Node.js installed),
 or in browser applications, via a bundler such as Webpack or Vite.

-You can also use the sdk with [Deno](https://deno.land/) (`import npm:matrix-js-sdk`) but its not officialy supported.
+You can also use the sdk with [Deno](https://deno.land/) (`import npm:matrix-js-sdk`) but its not officially supported.

 ## Emitted events

@@ -307,8 +307,6 @@ Then visit `http://localhost:8005` to see the API docs.

 ## Initialization

-**Do not use `matrixClient.initLegacyCrypto()`. This method is deprecated and no longer maintained.**
-
 To initialize the end-to-end encryption support in the matrix client:

 ```javascript
@@ -323,6 +321,8 @@ const matrixClient = sdk.createClient({
 await matrixClient.initRustCrypto();
 ```

+Note that by default it will attempt to use the Indexed DB provided by the browser as a crypto store. If running outside the browser, you will need to pass [an options object](https://matrix-org.github.io/matrix-js-sdk/classes/matrix.MatrixClient.html#initrustcrypto) which includes `useIndexedDB: false`, to use an ephemeral in-memory store instead. Note that without a persistent store, you'll need to create a new device on the server side (with [`MatrixClient.loginRequest`](https://matrix-org.github.io/matrix-js-sdk/classes/matrix.MatrixClient.html#loginrequest)) each time your application starts.
+
 After calling `initRustCrypto`, you can obtain a reference to the [`CryptoApi`](https://matrix-org.github.io/matrix-js-sdk/interfaces/crypto_api.CryptoApi.html) interface, which is the main entry point for end-to-end encryption, by calling [`MatrixClient.getCrypto`](https://matrix-org.github.io/matrix-js-sdk/classes/matrix.MatrixClient.html#getCrypto).

 **WARNING**: the cryptography stack is not thread-safe. Having multiple `MatrixClient` instances connected to the same Indexed DB will cause data corruption and decryption failures. The application layer is responsible for ensuring that only one `MatrixClient` issue is instantiated at a time.
@@ -26,6 +26,7 @@ module.exports = {
        ],
    ],
    plugins: [
+        ["@babel/plugin-proposal-decorators", { version: "2023-11" }],
        "@babel/plugin-transform-numeric-separator",
        "@babel/plugin-transform-class-properties",
        "@babel/plugin-transform-object-rest-spread",
@@ -0,0 +1,288 @@
+## Guiding principles
+
+1. We want the lint rules to feel natural for most team members. No one should have to think too much
+   about the linter.
+2. We want to stay relatively close to [industry standards](https://google.github.io/styleguide/tsguide.html)
+   to make onboarding easier.
+3. We describe what good code looks like rather than point out bad examples. We do this to avoid
+   excessively punishing people for writing code which fails the linter.
+4. When something isn't covered by the style guide, we come up with a reasonable rule rather than
+   claim that it "passes the linter". We update the style guide and linter accordingly.
+5. While we aim to improve readability, understanding, and other aspects of the code, we deliberately
+   do not let solely our personal preferences drive decisions.
+6. We aim to have an understandable guide.
+
+## Coding practices
+
+1. Lint rules enforce decisions made by this guide. The lint rules and this guide are kept in
+   perfect sync.
+2. Commit messages are descriptive for the changes. When the project supports squash merging,
+   only the squashed commit needs to have a descriptive message.
+3. When there is disagreement with a code style approved by the linter, a PR is opened against
+   the lint rules rather than making exceptions on the responsible code PR.
+4. Rules which are intentionally broken (via eslint-ignore, @ts-ignore, etc) have a comment
+   included in the immediate vicinity for why. Determination of whether this is valid applies at
+   code review time.
+5. When editing a file, nearby code is updated to meet the modern standards. "Nearby" is subjective,
+   but should be whatever is reasonable at review time. Such an example might be to update the
+   class's code style, but not the file's.
+    1. These changes should be minor enough to include in the same commit without affecting a code
+       reviewer's job.
+
+## All code
+
+Unless otherwise specified, the following applies to all code:
+
+1. Files must be formatted with Prettier.
+2. 120 character limit per line. Match existing code in the file if it is using a lower guide.
+3. A tab/indentation is 4 spaces.
+4. Newlines are Unix.
+5. A file has a single empty line at the end.
+6. Lines are trimmed of all excess whitespace, including blank lines.
+7. Long lines are broken up for readability.
+
+## TypeScript / JavaScript
+
+1. Write TypeScript. Turn JavaScript into TypeScript when working in the area.
+2. Use [TSDoc](https://tsdoc.org/) to document your code. See [Comments](#comments) below.
+3. Use named exports.
+4. Use semicolons for block/line termination.
+    1. Except when defining interfaces, classes, and non-arrow functions specifically.
+5. When a statement's body is a single line, it must be written without curly braces, so long as the body is placed on
+   the same line as the statement.
+
+    ```typescript
+    if (x) doThing();
+    ```
+
+6. Blocks for `if`, `for`, `switch` and so on must have a space surrounding the condition, but not
+   within the condition.
+
+    ```typescript
+    if (x) {
+        doThing();
+    }
+    ```
+
+7. lowerCamelCase is used for function and variable naming.
+8. UpperCamelCase is used for general naming.
+9. Interface names should not be marked with an uppercase `I`.
+10. One variable declaration per line.
+11. If a variable is not receiving a value on declaration, its type must be defined.
+
+    ```typescript
+    let errorMessage: Optional<string>;
+    ```
+
+12. Objects can use shorthand declarations, including mixing of types.
+
+    ```typescript
+    {
+        room,
+        prop: this.prop,
+    }
+    // ... or ...
+    { room, prop: this.prop }
+    ```
+
+13. Object keys should always be non-strings when possible.
+
+    ```typescript
+    {
+        property: "value",
+        "m.unavoidable": true,
+        [EventType.RoomMessage]: true,
+    }
+    ```
+
+14. If a variable's type should be boolean, make sure it really is one.
+
+    ```typescript
+    const isRealUser = !!userId && ...; // good
+    const isRealUser = Boolean(userId) && Boolean(userName); // also good
+    const isRealUser = Boolean(userId) && isReal; // also good (where isReal is another boolean variable)
+    const isRealUser = Boolean(userId && userName); // also fine
+    const isRealUser = Boolean(userId || userName); // good: same as &&
+    const isRealUser = userId && ...;   // bad: isRealUser is userId's type, not a boolean
+
+    if (userId) // fine: userId is evaluated for truthiness, not stored as a boolean
+    ```
+
+15. Use `switch` statements when checking against more than a few enum-like values.
+16. Use `const` for constants, `let` for mutability.
+17. Describe types exhaustively (ensure noImplictAny would pass).
+    1. Notable exceptions are arrow functions used as parameters, when a void return type is
+       obvious, and when declaring and assigning a variable in the same line.
+18. Declare member visibility (public/private/protected).
+19. Private members are private and not prefixed unless required for naming conflicts.
+    1. Convention is to use an underscore or the word "internal" to denote conflicted member names.
+    2. "Conflicted" typically refers to a getter which wants the same name as the underlying variable.
+20. Prefer readonly members over getters backed by a variable, unless an internal setter is required.
+21. Prefer Interfaces for object definitions, and types for parameter-value-only declarations.
+
+    1. Note that an explicit type is optional if not expected to be used outside of the function call,
+       unlike in this example:
+
+        ```typescript
+        interface MyObject {
+            hasString: boolean;
+        }
+
+        type Options = MyObject | string;
+
+        function doThing(arg: Options) {
+            // ...
+        }
+        ```
+
+22. Variables/properties which are `public static` should also be `readonly` when possible.
+23. Interface and type properties are terminated with semicolons, not commas.
+24. Prefer arrow formatting when declaring functions for interfaces/types:
+
+    ```typescript
+    interface Test {
+        myCallback: (arg: string) => Promise<void>;
+    }
+    ```
+
+25. Prefer a type definition over an inline type. For example, define an interface.
+26. Always prefer to add types or declare a type over the use of `any`. Prefer inferred types
+    when they are not `any`.
+    1. When using `any`, a comment explaining why must be present.
+27. `import` should be used instead of `require`, as `require` does not have types.
+28. Export only what can be reused.
+29. Prefer a type like `Optional<X>` (`type Optional<T> = T | null | undefined`) instead
+    of truly optional parameters.
+
+    1. A notable exception is when the likelihood of a bug is minimal, such as when a function
+       takes an argument that is more often not required than required. An example where the
+       `?` operator is inappropriate is when taking a room ID: typically the caller should
+       supply the room ID if it knows it, otherwise deliberately acknowledge that it doesn't
+       have one with `null`.
+
+        ```typescript
+        function doThingWithRoom(
+            thing: string,
+            room: Optional<string>, // require the caller to specify
+        ) {
+            // ...
+        }
+        ```
+
+30. There should be approximately one interface, class, or enum per file unless the file is named
+    "types.ts", "global.d.ts", or ends with "-types.ts".
+    1. The file name should match the interface, class, or enum name.
+31. Bulk functions can be declared in a single file, though named as "foo-utils.ts" or "utils/foo.ts".
+32. Imports are grouped by external module imports first, then by internal imports.
+33. File ordering is not strict, but should generally follow this sequence:
+    1. Licence header
+    2. Imports
+    3. Constants
+    4. Enums
+    5. Interfaces
+    6. Functions
+    7. Classes
+        1. Public/protected/private static properties
+        2. Public/protected/private properties
+        3. Constructors
+        4. Public/protected/private getters & setters
+        5. Protected and abstract functions
+        6. Public/private functions
+        7. Public/protected/private static functions
+34. Variable names should be noticeably unique from their types. For example, "str: string" instead
+    of "string: string".
+35. Use double quotes to enclose strings. You may use single quotes if the string contains double quotes.
+
+    ```typescript
+    const example1 = "simple string";
+    const example2 = 'string containing "double quotes"';
+    ```
+
+36. Prefer async-await to promise-chaining
+
+    ```typescript
+    async function () {
+        const result = await anotherAsyncFunction();
+        // ...
+    }
+    ```
+
+37. Avoid functions whose fundamental behaviour varies with different parameter types.
+    Multiple return types are fine, but if the function's behaviour is going to change significantly,
+    have two separate functions. For example, `SDKConfig.get()` with a string param which returns the
+    type according to the param given is ok, but `SDKConfig.get()` with no args returning the whole
+    config object would not be: this should just be a separate function.
+
+## Tests
+
+1. Tests must be written in TypeScript.
+2. Jest mocks are declared below imports, but above everything else.
+3. Use the following convention template:
+
+    ```typescript
+    // Describe the class, component, or file name.
+    describe("FooComponent", () => {
+        // all test inspecific variables go here
+
+        beforeEach(() => {
+            // exclude if not used.
+        });
+
+        afterEach(() => {
+            // exclude if not used.
+        });
+
+        // Use "it should..." terminology
+        it("should call the correct API", async () => {
+            // test-specific variables go here
+            // function calls/state changes go here
+            // expectations go here
+        });
+    });
+
+    // If the file being tested is a utility class:
+    describe("foo-utils", () => {
+        describe("firstUtilFunction", () => {
+            it("should...", async () => {
+                // ...
+            });
+        });
+
+        describe("secondUtilFunction", () => {
+            it("should...", async () => {
+                // ...
+            });
+        });
+    });
+    ```
+
+## Comments
+
+1. As a general principle: be liberal with comments. This applies to all files: stylesheets as well as
+   JavaScript/TypeScript.
+
+    Good comments not only help future readers understand and maintain the code; they can also encourage good design
+    by clearly setting out how different parts of the codebase interact where that would otherwise be implicit and
+    subject to interpretation.
+
+2. Aim to document all types, methods, class properties, functions, etc, with [TSDoc](https://tsdoc.org/) doc comments.
+   This is _especially_ important for public interfaces in `matrix-js-sdk`, but is good practice in general.
+
+    Even very simple interfaces can often benefit from a doc-comment, both as a matter of consistency, and because simple
+    interfaces have a habit of becoming more complex over time.
+
+3. Inside a function, there is no need to comment every line, but consider:
+
+    - before a particular multiline section of code within the function, give an overview of what it does,
+      to make it easier for a reader to follow the flow through the function as a whole.
+    - if it is anything less than obvious, explain _why_ we are doing a particular operation, with particular emphasis
+      on how this function interacts with other parts of the codebase.
+
+4. When making changes to existing code, authors are expected to read existing comments and make any necessary changes
+   to ensure they remain accurate.
+
+5. Reviewers are encouraged to consider whether more comments would be useful, and to ask the author to add them.
+
+    It is natural for an author to feel that the code they have just written is "obvious" and that comments would be
+    redundant, whereas in reality it would take some time for reader unfamiliar with the code to understand it. A
+    reviewer is well-placed to make a more objective judgement.
@@ -1,6 +1,6 @@
 {
    "name": "matrix-js-sdk",
-    "version": "36.2.0-rc.0",
+    "version": "37.3.0",
    "description": "Matrix Client-Server SDK for Javascript",
    "engines": {
        "node": ">=20.0.0"
@@ -26,7 +26,7 @@
    },
    "repository": {
        "type": "git",
-        "url": "https://github.com/matrix-org/matrix-js-sdk"
+        "url": "git+https://github.com/matrix-org/matrix-js-sdk.git"
    },
    "keywords": [
        "matrix-org"
@@ -50,7 +50,7 @@
    ],
    "dependencies": {
        "@babel/runtime": "^7.12.5",
-        "@matrix-org/matrix-sdk-crypto-wasm": "^13.0.0",
+        "@matrix-org/matrix-sdk-crypto-wasm": "^14.0.1",
        "@matrix-org/olm": "3.2.15",
        "another-json": "^0.2.0",
        "bs58": "^6.0.0",
@@ -72,6 +72,7 @@
        "@babel/core": "^7.12.10",
        "@babel/eslint-parser": "^7.12.10",
        "@babel/eslint-plugin": "^7.12.10",
+        "@babel/plugin-proposal-decorators": "^7.25.9",
        "@babel/plugin-syntax-dynamic-import": "^7.8.3",
        "@babel/plugin-transform-class-properties": "^7.12.1",
        "@babel/plugin-transform-numeric-separator": "^7.12.7",
@@ -81,8 +82,7 @@
        "@babel/preset-typescript": "^7.12.7",
        "@casualbot/jest-sonar-reporter": "2.2.7",
        "@peculiar/webcrypto": "^1.4.5",
-        "@stylistic/eslint-plugin": "^2.9.0",
-        "@types/bs58": "^4.0.1",
+        "@stylistic/eslint-plugin": "^4.0.0",
        "@types/content-type": "^1.1.5",
        "@types/debug": "^4.1.7",
        "@types/jest": "^29.0.0",
@@ -96,12 +96,12 @@
        "debug": "^4.3.4",
        "eslint": "8.57.1",
        "eslint-config-google": "^0.14.0",
-        "eslint-config-prettier": "^9.0.0",
-        "eslint-import-resolver-typescript": "^3.5.1",
+        "eslint-config-prettier": "^10.0.0",
+        "eslint-import-resolver-typescript": "^4.0.0",
        "eslint-plugin-import": "^2.26.0",
        "eslint-plugin-jest": "^28.0.0",
        "eslint-plugin-jsdoc": "^50.0.0",
-        "eslint-plugin-matrix-org": "^2.0.1",
+        "eslint-plugin-matrix-org": "2.1.0",
        "eslint-plugin-n": "^14.0.0",
        "eslint-plugin-tsdoc": "^0.4.0",
        "eslint-plugin-unicorn": "^56.0.0",
@@ -117,13 +117,13 @@
        "lint-staged": "^15.0.2",
        "matrix-mock-request": "^2.5.0",
        "node-fetch": "^2.7.0",
-        "prettier": "3.4.2",
+        "prettier": "3.5.3",
        "rimraf": "^6.0.0",
        "ts-node": "^10.9.2",
-        "typedoc": "^0.27.0",
+        "typedoc": "^0.28.1",
        "typedoc-plugin-coverage": "^3.0.0",
-        "typedoc-plugin-mdn-links": "^4.0.0",
-        "typedoc-plugin-missing-exports": "^3.0.0",
+        "typedoc-plugin-mdn-links": "^5.0.0",
+        "typedoc-plugin-missing-exports": "^4.0.0",
        "typescript": "^5.4.2"
    },
    "@casualbot/jest-sonar-reporter": {
@@ -26,14 +26,17 @@ import MockHttpBackend from "matrix-mock-request";

 import type { IDeviceKeys, IOneTimeKey } from "../src/@types/crypto";
 import type { IE2EKeyReceiver } from "./test-utils/E2EKeyReceiver";
-import { LocalStorageCryptoStore } from "../src/crypto/store/localStorage-crypto-store";
 import { logger } from "../src/logger";
 import { syncPromise } from "./test-utils/test-utils";
-import { createClient, IStartClientOpts } from "../src/matrix";
-import { ICreateClientOpts, IDownloadKeyResult, MatrixClient, PendingEventOrdering } from "../src/client";
-import { MockStorageApi } from "./MockStorageApi";
-import { IKeysUploadResponse, IUploadKeysRequest } from "../src/client";
-import { ISyncResponder } from "./test-utils/SyncResponder";
+import { createClient, type IStartClientOpts } from "../src/matrix";
+import {
+    type ICreateClientOpts,
+    type IDownloadKeyResult,
+    type MatrixClient,
+    PendingEventOrdering,
+} from "../src/client";
+import { type IKeysUploadResponse, type IUploadKeysRequest } from "../src/client";
+import { type ISyncResponder } from "./test-utils/SyncResponder";

 /**
 * Wrapper for a MockStorageApi, MockHttpBackend and MatrixClient
@@ -55,10 +58,6 @@ export class TestClient implements IE2EKeyReceiver, ISyncResponder {
        sessionStoreBackend?: Storage,
        options?: Partial<ICreateClientOpts>,
    ) {
-        if (sessionStoreBackend === undefined) {
-            sessionStoreBackend = new MockStorageApi() as unknown as Storage;
-        }
-
        this.httpBackend = new MockHttpBackend();

        const fullOptions: ICreateClientOpts = {
@@ -69,10 +68,6 @@ export class TestClient implements IE2EKeyReceiver, ISyncResponder {
            fetchFn: this.httpBackend.fetchFn as typeof globalThis.fetch,
            ...options,
        };
-        if (!fullOptions.cryptoStore) {
-            // expose this so the tests can get to it
-            fullOptions.cryptoStore = new LocalStorageCryptoStore(sessionStoreBackend);
-        }
        this.client = createClient(fullOptions);

        this.deviceKeys = null;
@@ -18,13 +18,13 @@ import fetchMock from "fetch-mock-jest";
 import "fake-indexeddb/auto";
 import { IDBFactory } from "fake-indexeddb";

-import { CRYPTO_BACKENDS, InitCrypto, syncPromise } from "../../test-utils/test-utils";
-import { AuthDict, createClient, CryptoEvent, MatrixClient } from "../../../src";
+import { syncPromise } from "../../test-utils/test-utils";
+import { type AuthDict, createClient, type MatrixClient } from "../../../src";
 import { mockInitialApiRequests, mockSetupCrossSigningRequests } from "../../test-utils/mockEndpoints";
 import encryptAESSecretStorageItem from "../../../src/utils/encryptAESSecretStorageItem.ts";
-import { CryptoCallbacks, CrossSigningKey } from "../../../src/crypto-api";
+import { type CryptoCallbacks, CrossSigningKey } from "../../../src/crypto-api";
 import { SECRET_STORAGE_ALGORITHM_V1_AES } from "../../../src/secret-storage";
-import { ISyncResponder, SyncResponder } from "../../test-utils/SyncResponder";
+import { type ISyncResponder, SyncResponder } from "../../test-utils/SyncResponder";
 import { E2EKeyReceiver } from "../../test-utils/E2EKeyReceiver";
 import {
    MASTER_CROSS_SIGNING_PRIVATE_KEY_BASE64,
@@ -37,6 +37,7 @@ import {
 import * as testData from "../../test-utils/test-data";
 import { E2EKeyResponder } from "../../test-utils/E2EKeyResponder";
 import { AccountDataAccumulator } from "../../test-utils/AccountDataAccumulator";
+import { CryptoEvent } from "../../../src/crypto-api";

 afterEach(() => {
    // reset fake-indexeddb after each test, to make sure we don't leak connections
@@ -54,11 +55,7 @@ const TEST_DEVICE_ID = "xzcvb";
 * These tests work by intercepting HTTP requests via fetch-mock rather than mocking out bits of the client, so as
 * to provide the most effective integration tests possible.
 */
-describe.each(Object.entries(CRYPTO_BACKENDS))("cross-signing (%s)", (backend: string, initCrypto: InitCrypto) => {
-    // newBackendOnly is the opposite to `oldBackendOnly`: it will skip the test if we are running against the legacy
-    // backend. Once we drop support for legacy crypto, it will go away.
-    const newBackendOnly = backend === "rust-sdk" ? test : test.skip;
-
+describe("cross-signing", () => {
    let aliceClient: MatrixClient;

    /** an object which intercepts `/sync` requests from {@link #aliceClient} */
@@ -107,7 +104,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("cross-signing (%s)", (backend: s
                body: { errcode: "M_NOT_FOUND" },
            });

-            await initCrypto(aliceClient);
+            await aliceClient.initRustCrypto();
        },
        /* it can take a while to initialise the crypto library on the first pass, so bump up the timeout. */
        10000,
@@ -162,7 +159,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("cross-signing (%s)", (backend: s
            );
        });

-        newBackendOnly("get cross signing keys from secret storage and import them", async () => {
+        it("get cross signing keys from secret storage and import them", async () => {
            // Return public cross signing keys
            e2eKeyResponder.addCrossSigningData(SIGNED_CROSS_SIGNING_KEYS_DATA);

@@ -263,7 +260,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("cross-signing (%s)", (backend: s
            expect(calls.length).toEqual(0);
        });

-        newBackendOnly("will upload existing cross-signing keys to an established secret storage", async () => {
+        it("will upload existing cross-signing keys to an established secret storage", async () => {
            // This rather obscure codepath covers the case that:
            //   - 4S is set up and working
            //   - our device has private cross-signing keys, but has not published them to 4S
@@ -272,7 +269,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("cross-signing (%s)", (backend: s
            // a *different* device. Then, when we call `bootstrapCrossSigning` again, it should do the honours.

            mockSetupCrossSigningRequests();
-            const accountDataAccumulator = new AccountDataAccumulator();
+            const accountDataAccumulator = new AccountDataAccumulator(syncResponder);
            accountDataAccumulator.interceptGetAccountData();

            const authDict = { type: "test" };
@@ -420,9 +417,8 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("cross-signing (%s)", (backend: s
        function awaitCrossSigningKeysUpload() {
            return new Promise<any>((resolve) => {
                fetchMock.post(
-                    // legacy crypto uses /unstable/; /v3/ is correct
                    {
-                        url: new RegExp("/_matrix/client/(unstable|v3)/keys/device_signing/upload"),
+                        url: new RegExp("/_matrix/client/v3/keys/device_signing/upload"),
                        name: "upload-keys",
                    },
                    (url, options) => {
@@ -475,9 +471,6 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("cross-signing (%s)", (backend: s
            await aliceClient.startClient();
            await syncPromise(aliceClient);

-            // Wait for legacy crypto to find the device
-            await jest.advanceTimersByTimeAsync(10);
-
            const devices = await aliceClient.getCrypto()!.getUserDeviceInfo([aliceClient.getSafeUserId()]);
            expect(devices.get(aliceClient.getSafeUserId())!.has(testData.TEST_DEVICE_ID)).toBeTruthy();
        });
@@ -17,10 +17,10 @@ limitations under the License.
 import "fake-indexeddb/auto";
 import fetchMock from "fetch-mock-jest";

-import { ClientEvent, createClient, MatrixClient, MatrixEvent } from "../../../src";
+import { ClientEvent, createClient, type MatrixClient, MatrixEvent } from "../../../src";
 import { CryptoEvent } from "../../../src/crypto-api/index";
-import { RustCrypto } from "../../../src/rust-crypto/rust-crypto";
-import { AddSecretStorageKeyOpts } from "../../../src/secret-storage";
+import { type RustCrypto } from "../../../src/rust-crypto/rust-crypto";
+import { type AddSecretStorageKeyOpts } from "../../../src/secret-storage";
 import { E2EKeyReceiver } from "../../test-utils/E2EKeyReceiver";
 import { E2EKeyResponder } from "../../test-utils/E2EKeyResponder";
 import { emitPromise, EventCounter } from "../../test-utils/test-utils";
@@ -218,8 +218,8 @@ async function initializeSecretStorage(
            privateKey: new Uint8Array(32),
        };
    }
-    await matrixClient.bootstrapCrossSigning({ setupNewCrossSigning: true });
-    await matrixClient.bootstrapSecretStorage({
+    await matrixClient.getCrypto()!.bootstrapCrossSigning({ setupNewCrossSigning: true });
+    await matrixClient.getCrypto()!.bootstrapSecretStorage({
        createSecretStorageKey,
        setupNewSecretStorage: true,
        setupNewKeyBackup: false,
@@ -17,35 +17,28 @@ limitations under the License.
 import fetchMock from "fetch-mock-jest";
 import "fake-indexeddb/auto";
 import { IDBFactory } from "fake-indexeddb";
-import { Mocked } from "jest-mock";
+import { type Mocked } from "jest-mock";

 import {
    createClient,
-    Crypto,
    encodeBase64,
-    ICreateClientOpts,
-    IEvent,
-    IMegolmSessionData,
-    MatrixClient,
+    type ICreateClientOpts,
+    type IEvent,
+    type IMegolmSessionData,
+    type MatrixClient,
    TypedEventEmitter,
 } from "../../../src";
 import { SyncResponder } from "../../test-utils/SyncResponder";
 import { E2EKeyReceiver } from "../../test-utils/E2EKeyReceiver";
 import { E2EKeyResponder } from "../../test-utils/E2EKeyResponder";
 import { mockInitialApiRequests } from "../../test-utils/mockEndpoints";
-import {
-    advanceTimersUntil,
-    awaitDecryption,
-    CRYPTO_BACKENDS,
-    InitCrypto,
-    syncPromise,
-} from "../../test-utils/test-utils";
+import { advanceTimersUntil, awaitDecryption, syncPromise } from "../../test-utils/test-utils";
 import * as testData from "../../test-utils/test-data";
-import { KeyBackupInfo, KeyBackupSession } from "../../../src/crypto-api/keybackup";
+import { type KeyBackupInfo, type KeyBackupSession } from "../../../src/crypto-api/keybackup";
 import { flushPromises } from "../../test-utils/flushPromises";
-import { defer, IDeferred } from "../../../src/utils";
-import { decodeRecoveryKey, DecryptionFailureCode, CryptoEvent } from "../../../src/crypto-api";
-import { KeyBackup } from "../../../src/rust-crypto/backup.ts";
+import { defer, type IDeferred } from "../../../src/utils";
+import { decodeRecoveryKey, DecryptionFailureCode, CryptoEvent, type CryptoApi } from "../../../src/crypto-api";
+import { type KeyBackup } from "../../../src/rust-crypto/backup.ts";

 const ROOM_ID = testData.TEST_ROOM_ID;

@@ -114,14 +107,7 @@ function mockUploadEmitter(
    return emitter;
 }

-describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backend: string, initCrypto: InitCrypto) => {
-    // oldBackendOnly is an alternative to `it` or `test` which will skip the test if we are running against the
-    // Rust backend. Once we have full support in the rust sdk, it will go away.
-    const oldBackendOnly = backend === "rust-sdk" ? test.skip : test;
-    const newBackendOnly = backend === "libolm" ? test.skip : test;
-
-    const isNewBackend = backend === "rust-sdk";
-
+describe("megolm-keys backup", () => {
    let aliceClient: MatrixClient;
    /** an object which intercepts `/sync` requests on the test homeserver */
    let syncResponder: SyncResponder;
@@ -167,7 +153,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
            deviceId: TEST_DEVICE_ID,
            ...opts,
        });
-        await initCrypto(client);
+        await client.initRustCrypto();

        return client;
    }
@@ -248,11 +234,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe

            // On the first decryption attempt, decryption fails.
            await awaitDecryption(event);
-            expect(event.decryptionFailureReason).toEqual(
-                isNewBackend
-                    ? DecryptionFailureCode.HISTORICAL_MESSAGE_WORKING_BACKUP
-                    : DecryptionFailureCode.MEGOLM_UNKNOWN_INBOUND_SESSION_ID,
-            );
+            expect(event.decryptionFailureReason).toEqual(DecryptionFailureCode.HISTORICAL_MESSAGE_WORKING_BACKUP);

            // Eventually, decryption succeeds.
            await awaitDecryption(event, { waitOnDecryptionFailure: true });
@@ -312,7 +294,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
    });

    describe("recover from backup", () => {
-        let aliceCrypto: Crypto.CryptoApi;
+        let aliceCrypto: CryptoApi;

        beforeEach(async () => {
            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
@@ -344,43 +326,14 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
            fetchMock.get("express:/_matrix/client/v3/room_keys/keys", fullBackup);

            const check = await aliceCrypto.checkKeyBackupAndEnable();
-
-            let onKeyCached: () => void;
-            const awaitKeyCached = new Promise<void>((resolve) => {
-                onKeyCached = resolve;
-            });
-
            await aliceCrypto.storeSessionBackupPrivateKey(
                decodeRecoveryKey(testData.BACKUP_DECRYPTION_KEY_BASE58),
                check!.backupInfo!.version!,
            );

-            const result = await advanceTimersUntil(
-                isNewBackend
-                    ? aliceCrypto.restoreKeyBackup()
-                    : aliceClient.restoreKeyBackupWithRecoveryKey(
-                          testData.BACKUP_DECRYPTION_KEY_BASE58,
-                          undefined,
-                          undefined,
-                          check!.backupInfo!,
-                          {
-                              cacheCompleteCallback: () => onKeyCached(),
-                          },
-                      ),
-            );
+            const result = await advanceTimersUntil(aliceCrypto.restoreKeyBackup());

            expect(result.imported).toStrictEqual(1);
-
-            if (isNewBackend) return;
-
-            await awaitKeyCached;
-
-            // The key should be now cached
-            const afterCache = await advanceTimersUntil(
-                aliceClient.restoreKeyBackupWithCache(undefined, undefined, check!.backupInfo!),
-            );
-
-            expect(afterCache.imported).toStrictEqual(1);
        });

        /**
@@ -413,13 +366,8 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe

        it("Should import full backup in chunks", async function () {
            const importMockImpl = jest.fn();
-            if (isNewBackend) {
-                // @ts-ignore - mock a private method for testing purpose
-                jest.spyOn(aliceCrypto.backupManager, "importBackedUpRoomKeys").mockImplementation(importMockImpl);
-            } else {
-                // @ts-ignore - mock a private method for testing purpose
-                jest.spyOn(aliceCrypto, "importBackedUpRoomKeys").mockImplementation(importMockImpl);
-            }
+            // @ts-ignore - mock a private method for testing purpose
+            jest.spyOn(aliceCrypto.backupManager, "importBackedUpRoomKeys").mockImplementation(importMockImpl);

            // We need several rooms with several sessions to test chunking
            const { response, expectedTotal } = createBackupDownloadResponse([45, 300, 345, 12, 130]);
@@ -434,19 +382,9 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
            );

            const progressCallback = jest.fn();
-            const result = await (isNewBackend
-                ? aliceCrypto.restoreKeyBackup({
-                      progressCallback,
-                  })
-                : aliceClient.restoreKeyBackupWithRecoveryKey(
-                      testData.BACKUP_DECRYPTION_KEY_BASE58,
-                      undefined,
-                      undefined,
-                      check!.backupInfo!,
-                      {
-                          progressCallback,
-                      },
-                  ));
+            const result = await aliceCrypto.restoreKeyBackup({
+                progressCallback,
+            });

            expect(result.imported).toStrictEqual(expectedTotal);
            // Should be called 5 times: 200*4 plus one chunk with the remaining 32
@@ -489,13 +427,8 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
                // Ok for other chunks
                .mockResolvedValue(undefined);

-            if (isNewBackend) {
-                // @ts-ignore - mock a private method for testing purpose
-                jest.spyOn(aliceCrypto.backupManager, "importBackedUpRoomKeys").mockImplementation(importMockImpl);
-            } else {
-                // @ts-ignore - mock a private method for testing purpose
-                jest.spyOn(aliceCrypto, "importBackedUpRoomKeys").mockImplementation(importMockImpl);
-            }
+            // @ts-ignore - mock a private method for testing purpose
+            jest.spyOn(aliceCrypto.backupManager, "importBackedUpRoomKeys").mockImplementation(importMockImpl);

            const { response, expectedTotal } = createBackupDownloadResponse([100, 300]);

@@ -508,17 +441,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
            );

            const progressCallback = jest.fn();
-            const result = await (isNewBackend
-                ? aliceCrypto.restoreKeyBackup({ progressCallback })
-                : aliceClient.restoreKeyBackupWithRecoveryKey(
-                      testData.BACKUP_DECRYPTION_KEY_BASE58,
-                      undefined,
-                      undefined,
-                      check!.backupInfo!,
-                      {
-                          progressCallback,
-                      },
-                  ));
+            const result = await aliceCrypto.restoreKeyBackup({ progressCallback });

            expect(result.total).toStrictEqual(expectedTotal);
            // A chunk failed to import
@@ -574,67 +497,17 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
                check!.backupInfo!.version!,
            );

-            const result = await (isNewBackend
-                ? aliceCrypto.restoreKeyBackup()
-                : aliceClient.restoreKeyBackupWithRecoveryKey(
-                      testData.BACKUP_DECRYPTION_KEY_BASE58,
-                      undefined,
-                      undefined,
-                      check!.backupInfo!,
-                  ));
+            const result = await aliceCrypto.restoreKeyBackup();

            expect(result.total).toStrictEqual(expectedTotal);
            // A chunk failed to import
            expect(result.imported).toStrictEqual(expectedTotal - decryptionFailureCount);
        });

-        oldBackendOnly("recover specific session from backup", async function () {
-            fetchMock.get(
-                "express:/_matrix/client/v3/room_keys/keys/:room_id/:session_id",
-                testData.CURVE25519_KEY_BACKUP_DATA,
-            );
+        it("Should get the decryption key from the secret storage and restore the key backup", async function () {
+            // @ts-ignore - mock a private method for testing purpose
+            jest.spyOn(aliceCrypto.secretStorage, "get").mockResolvedValue(testData.BACKUP_DECRYPTION_KEY_BASE64);

-            const check = await aliceCrypto.checkKeyBackupAndEnable();
-
-            const result = await advanceTimersUntil(
-                aliceClient.restoreKeyBackupWithRecoveryKey(
-                    testData.BACKUP_DECRYPTION_KEY_BASE58,
-                    ROOM_ID,
-                    testData.MEGOLM_SESSION_DATA.session_id,
-                    check!.backupInfo!,
-                ),
-            );
-
-            expect(result.imported).toStrictEqual(1);
-        });
-
-        newBackendOnly(
-            "Should get the decryption key from the secret storage and restore the key backup",
-            async function () {
-                // @ts-ignore - mock a private method for testing purpose
-                jest.spyOn(aliceCrypto.secretStorage, "get").mockResolvedValue(testData.BACKUP_DECRYPTION_KEY_BASE64);
-
-                const fullBackup = {
-                    rooms: {
-                        [ROOM_ID]: {
-                            sessions: {
-                                [testData.MEGOLM_SESSION_DATA.session_id]: testData.CURVE25519_KEY_BACKUP_DATA,
-                            },
-                        },
-                    },
-                };
-                fetchMock.get("express:/_matrix/client/v3/room_keys/keys", fullBackup);
-
-                await aliceCrypto.loadSessionBackupPrivateKeyFromSecretStorage();
-                const decryptionKey = await aliceCrypto.getSessionBackupPrivateKey();
-                expect(encodeBase64(decryptionKey!)).toStrictEqual(testData.BACKUP_DECRYPTION_KEY_BASE64);
-
-                const result = await aliceCrypto.restoreKeyBackup();
-                expect(result.imported).toStrictEqual(1);
-            },
-        );
-
-        oldBackendOnly("Fails on bad recovery key", async function () {
            const fullBackup = {
                rooms: {
                    [ROOM_ID]: {
@@ -644,22 +517,17 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
                    },
                },
            };
-
            fetchMock.get("express:/_matrix/client/v3/room_keys/keys", fullBackup);

-            const check = await aliceCrypto.checkKeyBackupAndEnable();
+            await aliceCrypto.loadSessionBackupPrivateKeyFromSecretStorage();
+            const decryptionKey = await aliceCrypto.getSessionBackupPrivateKey();
+            expect(encodeBase64(decryptionKey!)).toStrictEqual(testData.BACKUP_DECRYPTION_KEY_BASE64);

-            await expect(
-                aliceClient.restoreKeyBackupWithRecoveryKey(
-                    "EsTx A7Xn aNFF k3jH zpV3 MQoN LJEg mscC HecF 982L wC77 mYQD",
-                    undefined,
-                    undefined,
-                    check!.backupInfo!,
-                ),
-            ).rejects.toThrow();
+            const result = await aliceCrypto.restoreKeyBackup();
+            expect(result.imported).toStrictEqual(1);
        });

-        newBackendOnly("Should throw an error if the decryption key is not found in cache", async () => {
+        it("Should throw an error if the decryption key is not found in cache", async () => {
            await expect(aliceCrypto.restoreKeyBackup()).rejects.toThrow("No decryption key found in crypto store");
        });
    });
@@ -968,7 +836,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
        expect(backupStatus).toStrictEqual(testData.SIGNED_BACKUP_DATA.version);
    });

-    newBackendOnly("getKeyBackupInfo() should not return a backup if the active backup has been deleted", async () => {
+    it("getKeyBackupInfo() should not return a backup if the active backup has been deleted", async () => {
        // 404 means that there is no active backup
        fetchMock.get("express:/_matrix/client/v3/room_keys/version", 404);
        fetchMock.delete(`express:/_matrix/client/v3/room_keys/version/${testData.SIGNED_BACKUP_DATA.version}`, {});
@@ -1077,7 +945,29 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backe
            expect(await aliceCrypto.getActiveSessionBackupVersion()).toEqual(testData.SIGNED_BACKUP_DATA.version);
        });

-        it("does not enable a backup signed by an untrusted device", async () => {
+        it("enables a backup not signed by a trusted device, when we have the decryption key", async () => {
+            aliceClient = await initTestClient();
+            const aliceCrypto = aliceClient.getCrypto()!;
+
+            // download the device list, to match the trusted-device case
+            await aliceClient.startClient();
+            await waitForDeviceList();
+
+            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
+
+            // Alice does *not* trust the device that signed the backup, but *does* have the decryption key.
+            await aliceCrypto.storeSessionBackupPrivateKey(
+                Buffer.from(testData.BACKUP_DECRYPTION_KEY_BASE64, "base64"),
+                testData.SIGNED_BACKUP_DATA.version!,
+            );
+
+            const result = await aliceCrypto.checkKeyBackupAndEnable();
+            expect(result).toBeTruthy();
+            expect(result!.trustInfo).toEqual({ trusted: false, matchesDecryptionKey: true });
+            expect(await aliceCrypto.getActiveSessionBackupVersion()).toEqual(testData.SIGNED_BACKUP_DATA.version);
+        });
+
+        it("does not enable a backup signed by an untrusted device when we do not have the decryption key", async () => {
            aliceClient = await initTestClient();
            const aliceCrypto = aliceClient.getCrypto()!;

@@ -1,693 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-Copyright 2017 Vector Creations Ltd
-Copyright 2018 New Vector 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 file consists of a set of integration tests which try to simulate
- * communication via an Olm-encrypted room between two users, Alice and Bob.
- *
- * Note that megolm (group) conversation is not tested here.
- *
- * See also `crypto.spec.js`.
- */
-
-// load olm before the sdk if possible
-import "../../olm-loader";
-
-import type { Session } from "@matrix-org/olm";
-import type { IDeviceKeys, IOneTimeKey } from "../../../src/@types/crypto";
-import { logger } from "../../../src/logger";
-import * as testUtils from "../../test-utils/test-utils";
-import { TestClient } from "../../TestClient";
-import { CRYPTO_ENABLED, IClaimKeysRequest, IQueryKeysRequest, IUploadKeysRequest } from "../../../src/client";
-import { ClientEvent, IContent, ISendEventResponse, MatrixClient, MatrixEvent, MsgType } from "../../../src/matrix";
-import { DeviceInfo } from "../../../src/crypto/deviceinfo";
-import { KnownMembership } from "../../../src/@types/membership";
-
-let aliTestClient: TestClient;
-const roomId = "!room:localhost";
-const aliUserId = "@ali:localhost";
-const aliDeviceId = "zxcvb";
-const aliAccessToken = "aseukfgwef";
-let bobTestClient: TestClient;
-const bobUserId = "@bob:localhost";
-const bobDeviceId = "bvcxz";
-const bobAccessToken = "fewgfkuesa";
-let aliMessages: IContent[];
-let bobMessages: IContent[];
-
-type OlmPayload = ReturnType<Session["encrypt"]>;
-
-async function bobUploadsDeviceKeys(): Promise<void> {
-    bobTestClient.expectDeviceKeyUpload();
-    await bobTestClient.httpBackend.flushAllExpected();
-    expect(Object.keys(bobTestClient.deviceKeys!).length).not.toEqual(0);
-}
-
-/**
- * Set an expectation that querier will query uploader's keys; then flush the http request.
- *
- * @returns resolves once the http request has completed.
- */
-function expectQueryKeys(querier: TestClient, uploader: TestClient): Promise<number> {
-    // can't query keys before bob has uploaded them
-    expect(uploader.deviceKeys).toBeTruthy();
-
-    const uploaderKeys: Record<string, IDeviceKeys> = {};
-    uploaderKeys[uploader.deviceId!] = uploader.deviceKeys!;
-    querier.httpBackend.when("POST", "/keys/query").respond(200, function (_path, content: IQueryKeysRequest) {
-        expect(content.device_keys![uploader.userId!]).toEqual([]);
-        const result: Record<string, Record<string, IDeviceKeys>> = {};
-        result[uploader.userId!] = uploaderKeys;
-        return { device_keys: result };
-    });
-    return querier.httpBackend.flush("/keys/query", 1);
-}
-const expectAliQueryKeys = () => expectQueryKeys(aliTestClient, bobTestClient);
-const expectBobQueryKeys = () => expectQueryKeys(bobTestClient, aliTestClient);
-
-/**
- * Set an expectation that ali will claim one of bob's keys; then flush the http request.
- *
- * @returns resolves once the http request has completed.
- */
-async function expectAliClaimKeys(): Promise<void> {
-    const keys = await bobTestClient.awaitOneTimeKeyUpload();
-    aliTestClient.httpBackend.when("POST", "/keys/claim").respond(200, function (_path, content: IClaimKeysRequest) {
-        const claimType = content.one_time_keys![bobUserId][bobDeviceId];
-        expect(claimType).toEqual("signed_curve25519");
-        let keyId = "";
-        for (keyId in keys) {
-            if (bobTestClient.oneTimeKeys!.hasOwnProperty(keyId)) {
-                if (keyId.indexOf(claimType + ":") === 0) {
-                    break;
-                }
-            }
-        }
-        const result: Record<string, Record<string, Record<string, IOneTimeKey>>> = {};
-        result[bobUserId] = {};
-        result[bobUserId][bobDeviceId] = {};
-        result[bobUserId][bobDeviceId][keyId] = keys[keyId];
-        return { one_time_keys: result };
-    });
-    // it can take a while to process the key query, so give it some extra
-    // time, and make sure the claim actually happens rather than ploughing on
-    // confusingly.
-    const r = await aliTestClient.httpBackend.flush("/keys/claim", 1, 500);
-    expect(r).toEqual(1);
-}
-
-async function aliDownloadsKeys(): Promise<void> {
-    // can't query keys before bob has uploaded them
-    expect(bobTestClient.getSigningKey()).toBeTruthy();
-
-    const p1 = async () => {
-        await aliTestClient.client.downloadKeys([bobUserId]);
-        const devices = aliTestClient.client.getStoredDevicesForUser(bobUserId);
-        expect(devices.length).toEqual(1);
-        expect(devices[0].deviceId).toEqual("bvcxz");
-    };
-    const p2 = expectAliQueryKeys;
-
-    // check that the localStorage is updated as we expect (not sure this is
-    // an integration test, but meh)
-    await Promise.all([p1(), p2()]);
-    await aliTestClient.client.crypto!.deviceList.saveIfDirty();
-    // @ts-ignore - protected
-    aliTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-        const devices = data!.devices[bobUserId]!;
-        expect(devices[bobDeviceId].keys).toEqual(bobTestClient.deviceKeys!.keys);
-        expect(devices[bobDeviceId].verified).toBe(DeviceInfo.DeviceVerification.UNVERIFIED);
-    });
-}
-
-async function clientEnablesEncryption(client: MatrixClient): Promise<void> {
-    await client.setRoomEncryption(roomId, {
-        algorithm: "m.olm.v1.curve25519-aes-sha2",
-    });
-    expect(client.isRoomEncrypted(roomId)).toBeTruthy();
-}
-const aliEnablesEncryption = () => clientEnablesEncryption(aliTestClient.client);
-const bobEnablesEncryption = () => clientEnablesEncryption(bobTestClient.client);
-
-/**
- * Ali sends a message, first claiming e2e keys. Set the expectations and
- * check the results.
- *
- * @returns which resolves to the ciphertext for Bob's device.
- */
-async function aliSendsFirstMessage(): Promise<OlmPayload> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_, ciphertext] = await Promise.all([
-        sendMessage(aliTestClient.client),
-        expectAliQueryKeys().then(expectAliClaimKeys).then(expectAliSendMessageRequest),
-    ]);
-    return ciphertext;
-}
-
-/**
- * Ali sends a message without first claiming e2e keys. Set the expectations
- * and check the results.
- *
- * @returns which resolves to the ciphertext for Bob's device.
- */
-async function aliSendsMessage(): Promise<OlmPayload> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_, ciphertext] = await Promise.all([sendMessage(aliTestClient.client), expectAliSendMessageRequest()]);
-    return ciphertext;
-}
-
-/**
- * Bob sends a message, first querying (but not claiming) e2e keys. Set the
- * expectations and check the results.
- *
- * @returns which resolves to the ciphertext for Ali's device.
- */
-async function bobSendsReplyMessage(): Promise<OlmPayload> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_, ciphertext] = await Promise.all([
-        sendMessage(bobTestClient.client),
-        expectBobQueryKeys().then(expectBobSendMessageRequest),
-    ]);
-    return ciphertext;
-}
-
-/**
- * Set an expectation that Ali will send a message, and flush the request
- *
- * @returns which resolves to the ciphertext for Bob's device.
- */
-async function expectAliSendMessageRequest(): Promise<OlmPayload> {
-    const content = await expectSendMessageRequest(aliTestClient.httpBackend);
-    aliMessages.push(content);
-    expect(Object.keys(content.ciphertext)).toEqual([bobTestClient.getDeviceKey()]);
-    const ciphertext = content.ciphertext[bobTestClient.getDeviceKey()];
-    expect(ciphertext).toBeTruthy();
-    return ciphertext;
-}
-
-/**
- * Set an expectation that Bob will send a message, and flush the request
- *
- * @returns which resolves to the ciphertext for Bob's device.
- */
-async function expectBobSendMessageRequest(): Promise<OlmPayload> {
-    const content = await expectSendMessageRequest(bobTestClient.httpBackend);
-    bobMessages.push(content);
-    const aliKeyId = "curve25519:" + aliDeviceId;
-    const aliDeviceCurve25519Key = aliTestClient.deviceKeys!.keys[aliKeyId];
-    expect(Object.keys(content.ciphertext)).toEqual([aliDeviceCurve25519Key]);
-    const ciphertext = content.ciphertext[aliDeviceCurve25519Key];
-    expect(ciphertext).toBeTruthy();
-    return ciphertext;
-}
-
-function sendMessage(client: MatrixClient): Promise<ISendEventResponse> {
-    return client.sendMessage(roomId, { msgtype: MsgType.Text, body: "Hello, World" });
-}
-
-async function expectSendMessageRequest(httpBackend: TestClient["httpBackend"]): Promise<IContent> {
-    const path = "/send/m.room.encrypted/";
-    const prom = new Promise<IContent>((resolve) => {
-        httpBackend.when("PUT", path).respond(200, function (_path, content) {
-            resolve(content);
-            return {
-                event_id: "asdfgh",
-            };
-        });
-    });
-
-    // it can take a while to process the key query
-    await httpBackend.flush(path, 1);
-    return prom;
-}
-
-function aliRecvMessage(): Promise<void> {
-    const message = bobMessages.shift()!;
-    return recvMessage(aliTestClient.httpBackend, aliTestClient.client, bobUserId, message);
-}
-
-function bobRecvMessage(): Promise<void> {
-    const message = aliMessages.shift()!;
-    return recvMessage(bobTestClient.httpBackend, bobTestClient.client, aliUserId, message);
-}
-
-async function recvMessage(
-    httpBackend: TestClient["httpBackend"],
-    client: MatrixClient,
-    sender: string,
-    message: IContent,
-): Promise<void> {
-    const syncData = {
-        next_batch: "x",
-        rooms: {
-            join: {
-                [roomId]: {
-                    timeline: {
-                        events: [
-                            testUtils.mkEvent({
-                                type: "m.room.encrypted",
-                                room: roomId,
-                                content: message,
-                                sender: sender,
-                            }),
-                        ],
-                    },
-                },
-            },
-        },
-    };
-    httpBackend.when("GET", "/sync").respond(200, syncData);
-
-    const eventPromise = new Promise<MatrixEvent>((resolve) => {
-        const onEvent = function (event: MatrixEvent) {
-            // ignore the m.room.member events
-            if (event.getType() == "m.room.member") {
-                return;
-            }
-            logger.log(client.credentials.userId + " received event", event);
-
-            client.removeListener(ClientEvent.Event, onEvent);
-            resolve(event);
-        };
-        client.on(ClientEvent.Event, onEvent);
-    });
-
-    await httpBackend.flushAllExpected();
-
-    const preDecryptionEvent = await eventPromise;
-    expect(preDecryptionEvent.isEncrypted()).toBeTruthy();
-    // it may still be being decrypted
-    const event = await testUtils.awaitDecryption(preDecryptionEvent);
-    expect(event.getType()).toEqual("m.room.message");
-    expect(event.getContent()).toMatchObject({
-        msgtype: "m.text",
-        body: "Hello, World",
-    });
-    expect(event.isEncrypted()).toBeTruthy();
-}
-
-/**
- * Send an initial sync response to the client (which just includes the member
- * list for our test room).
- *
- * @returns which resolves when the sync has been flushed.
- */
-function firstSync(testClient: TestClient): Promise<void> {
-    // send a sync response including our test room.
-    const syncData = {
-        next_batch: "x",
-        rooms: {
-            join: {
-                [roomId]: {
-                    state: {
-                        events: [
-                            testUtils.mkMembership({
-                                mship: KnownMembership.Join,
-                                user: aliUserId,
-                            }),
-                            testUtils.mkMembership({
-                                mship: KnownMembership.Join,
-                                user: bobUserId,
-                            }),
-                        ],
-                    },
-                    timeline: {
-                        events: [],
-                    },
-                },
-            },
-        },
-    };
-
-    testClient.httpBackend.when("GET", "/sync").respond(200, syncData);
-    return testClient.flushSync();
-}
-
-describe("MatrixClient crypto", () => {
-    if (!CRYPTO_ENABLED) {
-        return;
-    }
-
-    beforeEach(async () => {
-        aliTestClient = new TestClient(aliUserId, aliDeviceId, aliAccessToken);
-        await aliTestClient.client.initLegacyCrypto();
-
-        bobTestClient = new TestClient(bobUserId, bobDeviceId, bobAccessToken);
-        await bobTestClient.client.initLegacyCrypto();
-
-        aliMessages = [];
-        bobMessages = [];
-    });
-
-    afterEach(() => {
-        aliTestClient.httpBackend.verifyNoOutstandingExpectation();
-        bobTestClient.httpBackend.verifyNoOutstandingExpectation();
-
-        return Promise.all([aliTestClient.stop(), bobTestClient.stop()]);
-    });
-
-    it("Bob uploads device keys", bobUploadsDeviceKeys);
-
-    it("handles failures to upload device keys", async () => {
-        // since device keys are uploaded asynchronously, there's not really much to do here other than fail the
-        // upload.
-        bobTestClient.httpBackend.when("POST", "/keys/upload").fail(0, new Error("bleh"));
-        await bobTestClient.httpBackend.flushAllExpected();
-    });
-
-    it("Ali downloads Bobs device keys", async () => {
-        await bobUploadsDeviceKeys();
-        await aliDownloadsKeys();
-    });
-
-    it("Ali gets keys with an invalid signature", async () => {
-        await bobUploadsDeviceKeys();
-        // tamper bob's keys
-        const bobDeviceKeys = bobTestClient.deviceKeys!;
-        expect(bobDeviceKeys.keys["curve25519:" + bobDeviceId]).toBeTruthy();
-        bobDeviceKeys.keys["curve25519:" + bobDeviceId] += "abc";
-        await Promise.all([aliTestClient.client.downloadKeys([bobUserId]), expectAliQueryKeys()]);
-        const devices = aliTestClient.client.getStoredDevicesForUser(bobUserId);
-        // should get an empty list
-        expect(devices).toEqual([]);
-    });
-
-    it("Ali gets keys with an incorrect userId", async () => {
-        const eveUserId = "@eve:localhost";
-
-        const bobDeviceKeys = {
-            algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
-            device_id: "bvcxz",
-            keys: {
-                "ed25519:bvcxz": "pYuWKMCVuaDLRTM/eWuB8OlXEb61gZhfLVJ+Y54tl0Q",
-                "curve25519:bvcxz": "7Gni0loo/nzF0nFp9847RbhElGewzwUXHPrljjBGPTQ",
-            },
-            user_id: "@eve:localhost",
-            signatures: {
-                "@eve:localhost": {
-                    "ed25519:bvcxz":
-                        "CliUPZ7dyVPBxvhSA1d+X+LYa5b2AYdjcTwG" + "0stXcIxjaJNemQqtdgwKDtBFl3pN2I13SEijRDCf1A8bYiQMDg",
-                },
-            },
-        };
-
-        const bobKeys: Record<string, typeof bobDeviceKeys> = {};
-        bobKeys[bobDeviceId] = bobDeviceKeys;
-        aliTestClient.httpBackend.when("POST", "/keys/query").respond(200, { device_keys: { [bobUserId]: bobKeys } });
-
-        await Promise.all([
-            aliTestClient.client.downloadKeys([bobUserId, eveUserId]),
-            aliTestClient.httpBackend.flush("/keys/query", 1),
-        ]);
-        const [bobDevices, eveDevices] = await Promise.all([
-            aliTestClient.client.getStoredDevicesForUser(bobUserId),
-            aliTestClient.client.getStoredDevicesForUser(eveUserId),
-        ]);
-        // should get an empty list
-        expect(bobDevices).toEqual([]);
-        expect(eveDevices).toEqual([]);
-    });
-
-    it("Ali gets keys with an incorrect deviceId", async () => {
-        const bobDeviceKeys = {
-            algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
-            device_id: "bad_device",
-            keys: {
-                "ed25519:bad_device": "e8XlY5V8x2yJcwa5xpSzeC/QVOrU+D5qBgyTK0ko+f0",
-                "curve25519:bad_device": "YxuuLG/4L5xGeP8XPl5h0d7DzyYVcof7J7do+OXz0xc",
-            },
-            user_id: "@bob:localhost",
-            signatures: {
-                "@bob:localhost": {
-                    "ed25519:bad_device":
-                        "fEFTq67RaSoIEVBJ8DtmRovbwUBKJ0A" + "me9m9PDzM9azPUwZ38Xvf6vv1A7W1PSafH4z3Y2ORIyEnZgHaNby3CQ",
-                },
-            },
-        };
-
-        const bobKeys: Record<string, typeof bobDeviceKeys> = {};
-        bobKeys[bobDeviceId] = bobDeviceKeys;
-        aliTestClient.httpBackend.when("POST", "/keys/query").respond(200, { device_keys: { [bobUserId]: bobKeys } });
-
-        await Promise.all([
-            aliTestClient.client.downloadKeys([bobUserId]),
-            aliTestClient.httpBackend.flush("/keys/query", 1),
-        ]);
-        const devices = aliTestClient.client.getStoredDevicesForUser(bobUserId);
-        // should get an empty list
-        expect(devices).toEqual([]);
-    });
-
-    it("Bob starts his client and uploads device keys and one-time keys", async () => {
-        await bobTestClient.start();
-        const keys = await bobTestClient.awaitOneTimeKeyUpload();
-        expect(Object.keys(keys).length).toEqual(5);
-        expect(Object.keys(bobTestClient.deviceKeys!).length).not.toEqual(0);
-    });
-
-    it("Ali sends a message", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-    });
-
-    it("Bob receives a message", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        bobTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve(new Map());
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-        await bobRecvMessage();
-    });
-
-    it("Bob receives a message with a bogus sender", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        bobTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve(new Map());
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-        const message = aliMessages.shift()!;
-        const syncData = {
-            next_batch: "x",
-            rooms: {
-                join: {
-                    [roomId]: {
-                        timeline: {
-                            events: [
-                                testUtils.mkEvent({
-                                    type: "m.room.encrypted",
-                                    room: roomId,
-                                    content: message,
-                                    sender: "@bogus:sender",
-                                }),
-                            ],
-                        },
-                    },
-                },
-            },
-        };
-        bobTestClient.httpBackend.when("GET", "/sync").respond(200, syncData);
-
-        const eventPromise = new Promise<MatrixEvent>((resolve) => {
-            const onEvent = function (event: MatrixEvent) {
-                logger.log(bobUserId + " received event", event);
-                resolve(event);
-            };
-            bobTestClient.client.once(ClientEvent.Event, onEvent);
-        });
-        await bobTestClient.httpBackend.flushAllExpected();
-        const preDecryptionEvent = await eventPromise;
-        expect(preDecryptionEvent.isEncrypted()).toBeTruthy();
-        // it may still be being decrypted
-        const event = await testUtils.awaitDecryption(preDecryptionEvent);
-        expect(event.getType()).toEqual("m.room.message");
-        expect(event.getContent().msgtype).toEqual("m.bad.encrypted");
-    });
-
-    it("Ali blocks Bob's device", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliDownloadsKeys();
-        aliTestClient.client.setDeviceBlocked(bobUserId, bobDeviceId, true);
-        const p1 = sendMessage(aliTestClient.client);
-        const p2 = expectSendMessageRequest(aliTestClient.httpBackend).then(function (sentContent) {
-            // no unblocked devices, so the ciphertext should be empty
-            expect(sentContent.ciphertext).toEqual({});
-        });
-        await Promise.all([p1, p2]);
-    });
-
-    it("Bob receives two pre-key messages", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        bobTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve(new Map());
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-        await bobRecvMessage();
-        await aliSendsMessage();
-        await bobRecvMessage();
-    });
-
-    it("Bob replies to the message", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        bobTestClient.expectKeyQuery({ device_keys: { [bobUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        await firstSync(aliTestClient);
-        await firstSync(bobTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-        bobTestClient.httpBackend.when("POST", "/keys/query").respond(200, {});
-        await bobRecvMessage();
-        await bobEnablesEncryption();
-        const ciphertext = await bobSendsReplyMessage();
-        expect(ciphertext.type).toEqual(1);
-        await aliRecvMessage();
-    });
-
-    it("Ali does a key query when encryption is enabled", async () => {
-        // enabling encryption in the room should make alice download devices
-        // for both members.
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await firstSync(aliTestClient);
-        const syncData = {
-            next_batch: "2",
-            rooms: {
-                join: {
-                    [roomId]: {
-                        state: {
-                            events: [
-                                testUtils.mkEvent({
-                                    type: "m.room.encryption",
-                                    skey: "",
-                                    content: {
-                                        algorithm: "m.olm.v1.curve25519-aes-sha2",
-                                    },
-                                }),
-                            ],
-                        },
-                    },
-                },
-            },
-        };
-
-        aliTestClient.httpBackend.when("GET", "/sync").respond(200, syncData);
-        await aliTestClient.httpBackend.flush("/sync", 1);
-        aliTestClient.expectKeyQuery({
-            device_keys: {
-                [bobUserId]: {},
-            },
-            failures: {},
-        });
-        await aliTestClient.httpBackend.flushAllExpected();
-    });
-
-    it("Upload new oneTimeKeys based on a /sync request - no count-asking", async () => {
-        // Send a response which causes a key upload
-        const httpBackend = aliTestClient.httpBackend;
-        const syncDataEmpty = {
-            next_batch: "a",
-            device_one_time_keys_count: {
-                signed_curve25519: 0,
-            },
-        };
-
-        // enqueue expectations:
-        // * Sync with empty one_time_keys => upload keys
-
-        logger.log(aliTestClient + ": starting");
-        httpBackend.when("GET", "/versions").respond(200, {});
-        httpBackend.when("GET", "/pushrules").respond(200, {});
-        httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
-        aliTestClient.expectDeviceKeyUpload();
-
-        // we let the client do a very basic initial sync, which it needs before
-        // it will upload one-time keys.
-        httpBackend.when("GET", "/sync").respond(200, syncDataEmpty);
-
-        await Promise.all([aliTestClient.client.startClient({}), httpBackend.flushAllExpected()]);
-        logger.log(aliTestClient + ": started");
-        httpBackend.when("POST", "/keys/upload").respond(200, (_path, content: IUploadKeysRequest) => {
-            expect(content.one_time_keys).toBeTruthy();
-            expect(content.one_time_keys).not.toEqual({});
-            expect(Object.keys(content.one_time_keys!).length).toBeGreaterThanOrEqual(1);
-            // cancel futher calls by telling the client
-            // we have more than we need
-            return {
-                one_time_key_counts: {
-                    signed_curve25519: 70,
-                },
-            };
-        });
-        await httpBackend.flushAllExpected();
-    });
-
-    it("Checks for outgoing room key requests for a given event's session", async () => {
-        const eventA0 = new MatrixEvent({
-            sender: "@bob:example.com",
-            room_id: "!someroom",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                session_id: "sessionid",
-                sender_key: "senderkey",
-            },
-        });
-        const eventA1 = new MatrixEvent({
-            sender: "@bob:example.com",
-            room_id: "!someroom",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                session_id: "sessionid",
-                sender_key: "senderkey",
-            },
-        });
-        const eventB = new MatrixEvent({
-            sender: "@bob:example.com",
-            room_id: "!someroom",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                session_id: "othersessionid",
-                sender_key: "senderkey",
-            },
-        });
-        const nonEncryptedEvent = new MatrixEvent({
-            sender: "@bob:example.com",
-            room_id: "!someroom",
-            content: {},
-        });
-
-        aliTestClient.client.crypto?.onSyncCompleted({});
-        await aliTestClient.client.cancelAndResendEventRoomKeyRequest(eventA0);
-        expect(await aliTestClient.client.getOutgoingRoomKeyRequest(eventA1)).not.toBeNull();
-        expect(await aliTestClient.client.getOutgoingRoomKeyRequest(eventB)).toBeNull();
-        expect(await aliTestClient.client.getOutgoingRoomKeyRequest(nonEncryptedEvent)).toBeNull();
-    });
-});
@@ -17,11 +17,19 @@ limitations under the License.
 import Olm from "@matrix-org/olm";
 import anotherjson from "another-json";

-import { IContent, IDeviceKeys, IDownloadKeyResult, IEvent, Keys, MatrixClient, SigningKeys } from "../../../src";
-import { IE2EKeyReceiver } from "../../test-utils/E2EKeyReceiver";
-import { ISyncResponder } from "../../test-utils/SyncResponder";
+import {
+    type IContent,
+    type IDeviceKeys,
+    type IDownloadKeyResult,
+    type IEvent,
+    type Keys,
+    type MatrixClient,
+    type SigningKeys,
+} from "../../../src";
+import { type IE2EKeyReceiver } from "../../test-utils/E2EKeyReceiver";
+import { type ISyncResponder } from "../../test-utils/SyncResponder";
 import { syncPromise } from "../../test-utils/test-utils";
-import { KeyBackupInfo } from "../../../src/crypto-api";
+import { type KeyBackupInfo } from "../../../src/crypto-api";

 /**
 * @module
@@ -18,12 +18,13 @@ import "fake-indexeddb/auto";
 import { IDBFactory } from "fake-indexeddb";
 import fetchMock from "fetch-mock-jest";

-import { createClient, CryptoEvent, IndexedDBCryptoStore } from "../../../src";
+import { createClient, IndexedDBCryptoStore } from "../../../src";
 import { populateStore } from "../../test-utils/test_indexeddb_cryptostore_dump";
 import { MSK_NOT_CACHED_DATASET } from "../../test-utils/test_indexeddb_cryptostore_dump/no_cached_msk_dump";
 import { IDENTITY_NOT_TRUSTED_DATASET } from "../../test-utils/test_indexeddb_cryptostore_dump/unverified";
 import { FULL_ACCOUNT_DATASET } from "../../test-utils/test_indexeddb_cryptostore_dump/full_account";
 import { EMPTY_ACCOUNT_DATASET } from "../../test-utils/test_indexeddb_cryptostore_dump/empty_account";
+import { CryptoEvent } from "../../../src/crypto-api";

 jest.setTimeout(15000);

@@ -18,8 +18,8 @@ import fetchMock from "fetch-mock-jest";
 import "fake-indexeddb/auto";
 import { IDBFactory } from "fake-indexeddb";

-import { CRYPTO_BACKENDS, getSyncResponse, InitCrypto, syncPromise } from "../../test-utils/test-utils";
-import { createClient, MatrixClient } from "../../../src";
+import { getSyncResponse, syncPromise } from "../../test-utils/test-utils";
+import { createClient, type MatrixClient } from "../../../src";
 import * as testData from "../../test-utils/test-data";
 import { E2EKeyResponder } from "../../test-utils/E2EKeyResponder";
 import { SyncResponder } from "../../test-utils/SyncResponder";
@@ -38,7 +38,7 @@ afterEach(() => {
 * These tests work by intercepting HTTP requests via fetch-mock rather than mocking out bits of the client, so as
 * to provide the most effective integration tests possible.
 */
-describe.each(Object.entries(CRYPTO_BACKENDS))("to-device-messages (%s)", (backend: string, initCrypto: InitCrypto) => {
+describe("to-device-messages", () => {
    let aliceClient: MatrixClient;

    /** an object which intercepts `/keys/query` requests on the test homeserver */
@@ -81,7 +81,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("to-device-messages (%s)", (backe
                { filter_id: "fid" },
            );

-            await initCrypto(aliceClient);
+            await aliceClient.initRustCrypto();
        },
        /* it can take a while to initialise the crypto library on the first pass, so bump up the timeout. */
        10000,
@@ -17,42 +17,35 @@ limitations under the License.
 import "fake-indexeddb/auto";

 import anotherjson from "another-json";
-import FetchMock from "fetch-mock";
 import fetchMock from "fetch-mock-jest";
 import { IDBFactory } from "fake-indexeddb";
 import { createHash } from "crypto";
 import Olm from "@matrix-org/olm";

+import type FetchMock from "fetch-mock";
 import {
    createClient,
-    CryptoEvent,
    DeviceVerification,
-    IContent,
-    ICreateClientOpts,
-    IEvent,
-    MatrixClient,
+    type IContent,
+    type ICreateClientOpts,
+    type IEvent,
+    type MatrixClient,
+    MatrixError,
    MatrixEvent,
    MatrixEventEvent,
 } from "../../../src";
 import {
    canAcceptVerificationRequest,
-    ShowQrCodeCallbacks,
-    ShowSasCallbacks,
+    type ShowQrCodeCallbacks,
+    type ShowSasCallbacks,
    VerificationPhase,
-    VerificationRequest,
+    type VerificationRequest,
    VerificationRequestEvent,
-    Verifier,
+    type Verifier,
    VerifierEvent,
 } from "../../../src/crypto-api/verification";
 import { defer, escapeRegExp } from "../../../src/utils";
-import {
-    awaitDecryption,
-    CRYPTO_BACKENDS,
-    emitPromise,
-    getSyncResponse,
-    InitCrypto,
-    syncPromise,
-} from "../../test-utils/test-utils";
+import { awaitDecryption, emitPromise, getSyncResponse, syncPromise } from "../../test-utils/test-utils";
 import { SyncResponder } from "../../test-utils/SyncResponder";
 import {
    BACKUP_DECRYPTION_KEY_BASE64,
@@ -79,9 +72,9 @@ import {
    encryptMegolmEvent,
    encryptSecretSend,
    getTestOlmAccountKeys,
-    ToDeviceEvent,
+    type ToDeviceEvent,
 } from "./olm-utils";
-import { KeyBackupInfo } from "../../../src/crypto-api";
+import { type KeyBackupInfo, CryptoEvent } from "../../../src/crypto-api";
 import { encodeBase64 } from "../../../src/base64";

 // The verification flows use javascript timers to set timeouts. We tell jest to use mock timer implementations
@@ -118,11 +111,7 @@ const TEST_HOMESERVER_URL = "https://alice-server.com";
 * to provide the most effective integration tests possible.
 */
 // we test with both crypto stacks...
-describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: string, initCrypto: InitCrypto) => {
-    // newBackendOnly is the opposite to `oldBackendOnly`: it will skip the test if we are running against the legacy
-    // backend. Once we drop support for legacy crypto, it will go away.
-    const newBackendOnly = backend === "rust-sdk" ? test : test.skip;
-
+describe("verification", () => {
    /** the client under test */
    let aliceClient: MatrixClient;

@@ -432,9 +421,8 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
                expect(requests[0].transactionId).toEqual(transactionId);
            }

-            // legacy crypto picks devices individually; rust crypto uses a broadcast message
-            const toDeviceMessage =
-                requestBody.messages[TEST_USER_ID]["*"] ?? requestBody.messages[TEST_USER_ID][TEST_DEVICE_ID];
+            // rust crypto uses a broadcast message
+            const toDeviceMessage = requestBody.messages[TEST_USER_ID]["*"];
            expect(toDeviceMessage.from_device).toEqual(aliceClient.deviceId);
            expect(toDeviceMessage.transaction_id).toEqual(transactionId);
        });
@@ -522,18 +510,12 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
            reciprocateQRCodeCallbacks.confirm();
            await sendToDevicePromise;

-            // at this point, on legacy crypto, the master key is already marked as trusted, and the request is "Done".
-            // Rust crypto, on the other hand, waits for the 'done' to arrive from the other side.
+            // Rust crypto waits for the 'done' to arrive from the other side.
            if (request.phase === VerificationPhase.Done) {
-                // legacy crypto: we're all done
                const userVerificationStatus = await aliceClient.getCrypto()!.getUserVerificationStatus(TEST_USER_ID);
                // eslint-disable-next-line jest/no-conditional-expect
                expect(userVerificationStatus.isCrossSigningVerified()).toBeTruthy();
                await verificationPromise;
-            } else {
-                // rust crypto: still in flight
-                // eslint-disable-next-line jest/no-conditional-expect
-                expect(request.phase).toEqual(VerificationPhase.Started);
            }

            // the dummy device replies with its own 'done'
@@ -569,7 +551,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
            expect(qrCodeBuffer).toBeUndefined();
        });

-        newBackendOnly("can verify another by scanning their QR code", async () => {
+        it("can verify another by scanning their QR code", async () => {
            aliceClient = await startTestClient();
            // we need cross-signing keys for a QR code verification
            e2eKeyResponder.addCrossSigningData(SIGNED_CROSS_SIGNING_KEYS_DATA);
@@ -907,7 +889,6 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
    describe("Send verification request in DM", () => {
        beforeEach(async () => {
            aliceClient = await startTestClient();
-            aliceClient.setGlobalErrorOnUnknownDevices(false);

            e2eKeyResponder.addCrossSigningData(BOB_SIGNED_CROSS_SIGNING_KEYS_DATA);
            e2eKeyResponder.addDeviceKeys(BOB_SIGNED_TEST_DEVICE_DATA);
@@ -990,21 +971,18 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
            testOlmAccount.create();

            aliceClient = await startTestClient();
-            aliceClient.setGlobalErrorOnUnknownDevices(false);
            syncResponder.sendOrQueueSyncResponse(getSyncResponse([BOB_TEST_USER_ID]));
            await syncPromise(aliceClient);

            // Rust crypto requires the sender's device keys before it accepts a
            // verification request.
-            if (backend === "rust-sdk") {
-                const crypto = aliceClient.getCrypto()!;
+            const crypto = aliceClient.getCrypto()!;

-                const bobDeviceKeys = getTestOlmAccountKeys(testOlmAccount, BOB_TEST_USER_ID, "BobDevice");
-                e2eKeyResponder.addDeviceKeys(bobDeviceKeys);
-                syncResponder.sendOrQueueSyncResponse({ device_lists: { changed: [BOB_TEST_USER_ID] } });
-                await syncPromise(aliceClient);
-                await crypto.getUserDeviceInfo([BOB_TEST_USER_ID]);
-            }
+            const bobDeviceKeys = getTestOlmAccountKeys(testOlmAccount, BOB_TEST_USER_ID, "BobDevice");
+            e2eKeyResponder.addDeviceKeys(bobDeviceKeys);
+            syncResponder.sendOrQueueSyncResponse({ device_lists: { changed: [BOB_TEST_USER_ID] } });
+            await syncPromise(aliceClient);
+            await crypto.getUserDeviceInfo([BOB_TEST_USER_ID]);
        });

        /**
@@ -1152,43 +1130,40 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
            expect(request?.otherUserId).toBe("@bob:xyz");
        });

-        newBackendOnly(
-            "If the verification request is not decrypted within 5 minutes, the request is ignored",
-            async () => {
-                const p2pSession = await createOlmSession(testOlmAccount, e2eKeyReceiver);
-                const groupSession = new Olm.OutboundGroupSession();
-                groupSession.create();
+        it("If the verification request is not decrypted within 5 minutes, the request is ignored", async () => {
+            const p2pSession = await createOlmSession(testOlmAccount, e2eKeyReceiver);
+            const groupSession = new Olm.OutboundGroupSession();
+            groupSession.create();

-                // make the room_key event, but don't send it yet
-                const toDeviceEvent = encryptGroupSessionKeyForAlice(groupSession, p2pSession);
+            // make the room_key event, but don't send it yet
+            const toDeviceEvent = encryptGroupSessionKeyForAlice(groupSession, p2pSession);

-                // Add verification request from Bob to Alice in the DM between them
-                returnRoomMessageFromSync(TEST_ROOM_ID, createEncryptedVerificationRequest(groupSession));
+            // Add verification request from Bob to Alice in the DM between them
+            returnRoomMessageFromSync(TEST_ROOM_ID, createEncryptedVerificationRequest(groupSession));

-                // Wait for the sync response to be processed
-                await syncPromise(aliceClient);
+            // Wait for the sync response to be processed
+            await syncPromise(aliceClient);

-                const room = aliceClient.getRoom(TEST_ROOM_ID)!;
-                const matrixEvent = room.getLiveTimeline().getEvents()[0];
+            const room = aliceClient.getRoom(TEST_ROOM_ID)!;
+            const matrixEvent = room.getLiveTimeline().getEvents()[0];

-                // wait for a first attempt at decryption: should fail
-                await awaitDecryption(matrixEvent);
-                expect(matrixEvent.getContent().msgtype).toEqual("m.bad.encrypted");
+            // wait for a first attempt at decryption: should fail
+            await awaitDecryption(matrixEvent);
+            expect(matrixEvent.getContent().msgtype).toEqual("m.bad.encrypted");

-                // Advance time by 5mins, the verification request should be ignored after that
-                jest.advanceTimersByTime(5 * 60 * 1000);
+            // Advance time by 5mins, the verification request should be ignored after that
+            jest.advanceTimersByTime(5 * 60 * 1000);

-                // Send Bob the room keys
-                returnToDeviceMessageFromSync(toDeviceEvent);
+            // Send Bob the room keys
+            returnToDeviceMessageFromSync(toDeviceEvent);

-                // Wait for the message to be decrypted
-                await awaitDecryption(matrixEvent, { waitOnDecryptionFailure: true });
+            // Wait for the message to be decrypted
+            await awaitDecryption(matrixEvent, { waitOnDecryptionFailure: true });

-                const request = aliceClient.getCrypto()!.findVerificationRequestDMInProgress(TEST_ROOM_ID, "@bob:xyz");
-                // the request should not be present
-                expect(request).not.toBeDefined();
-            },
-        );
+            const request = aliceClient.getCrypto()!.findVerificationRequestDMInProgress(TEST_ROOM_ID, "@bob:xyz");
+            // the request should not be present
+            expect(request).not.toBeDefined();
+        });
    });

    describe("Secrets are gossiped after verification", () => {
@@ -1260,7 +1235,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
            fetchMock.mockReset();
        });

-        newBackendOnly("Should request cross signing keys after verification", async () => {
+        it("Should request cross signing keys after verification", async () => {
            const requestPromises = mockSecretRequestAndGetPromises();

            await doInteractiveVerification();
@@ -1271,7 +1246,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
            await requestPromises.get("m.cross_signing.self_signing");
        });

-        newBackendOnly("Should accept the backup decryption key gossip if valid", async () => {
+        it("Should accept the backup decryption key gossip if valid", async () => {
            const requestPromises = mockSecretRequestAndGetPromises();

            await doInteractiveVerification();
@@ -1290,7 +1265,43 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
            expect(encodeBase64(cachedKey!)).toEqual(BACKUP_DECRYPTION_KEY_BASE64);
        });

-        newBackendOnly("Should not accept the backup decryption key gossip if private key do not match", async () => {
+        it("Should not accept the backup decryption key gossip when there is no server-side key backup", async () => {
+            const requestPromises = mockSecretRequestAndGetPromises();
+
+            await doInteractiveVerification();
+
+            const requestId = await requestPromises.get("m.megolm_backup.v1");
+
+            await sendBackupGossipAndExpectVersion(
+                requestId!,
+                BACKUP_DECRYPTION_KEY_BASE64,
+                new MatrixError({ errcode: "M_NOT_FOUND", error: "No backup found" }, 404),
+            );
+
+            // the backup secret should not be cached
+            const cachedKey = await retrieveBackupPrivateKeyWithDelay();
+            expect(cachedKey).toBeNull();
+        });
+
+        it("Should not accept the backup decryption key gossip when server-side key backup request errors", async () => {
+            const requestPromises = mockSecretRequestAndGetPromises();
+
+            await doInteractiveVerification();
+
+            const requestId = await requestPromises.get("m.megolm_backup.v1");
+
+            await sendBackupGossipAndExpectVersion(
+                requestId!,
+                BACKUP_DECRYPTION_KEY_BASE64,
+                new Error("Network Error!"),
+            );
+
+            // the backup secret should not be cached
+            const cachedKey = await retrieveBackupPrivateKeyWithDelay();
+            expect(cachedKey).toBeNull();
+        });
+
+        it("Should not accept the backup decryption key gossip if private key do not match", async () => {
            const requestPromises = mockSecretRequestAndGetPromises();

            await doInteractiveVerification();
@@ -1299,43 +1310,12 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st

            await sendBackupGossipAndExpectVersion(requestId!, BACKUP_DECRYPTION_KEY_BASE64, nonMatchingBackupInfo);

-            // We are lacking a way to signal that the secret has been received, so we wait a bit..
-            jest.useRealTimers();
-            await new Promise((resolve) => {
-                setTimeout(resolve, 500);
-            });
-            jest.useFakeTimers({ doNotFake: ["queueMicrotask"] });
-
            // the backup secret should not be cached
-            const cachedKey = await aliceClient.getCrypto()!.getSessionBackupPrivateKey();
+            const cachedKey = await retrieveBackupPrivateKeyWithDelay();
            expect(cachedKey).toBeNull();
        });

-        newBackendOnly("Should not accept the backup decryption key gossip if backup not trusted", async () => {
-            const requestPromises = mockSecretRequestAndGetPromises();
-
-            await doInteractiveVerification();
-
-            const requestId = await requestPromises.get("m.megolm_backup.v1");
-
-            const infoCopy = Object.assign({}, matchingBackupInfo);
-            delete infoCopy.auth_data.signatures;
-
-            await sendBackupGossipAndExpectVersion(requestId!, BACKUP_DECRYPTION_KEY_BASE64, infoCopy);
-
-            // We are lacking a way to signal that the secret has been received, so we wait a bit..
-            jest.useRealTimers();
-            await new Promise((resolve) => {
-                setTimeout(resolve, 500);
-            });
-            jest.useFakeTimers({ doNotFake: ["queueMicrotask"] });
-
-            // the backup secret should not be cached
-            const cachedKey = await aliceClient.getCrypto()!.getSessionBackupPrivateKey();
-            expect(cachedKey).toBeNull();
-        });
-
-        newBackendOnly("Should not accept the backup decryption key gossip if backup algorithm unknown", async () => {
+        it("Should not accept the backup decryption key gossip if backup algorithm unknown", async () => {
            const requestPromises = mockSecretRequestAndGetPromises();

            await doInteractiveVerification();
@@ -1348,19 +1328,12 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
                unknownAlgorithmBackupInfo,
            );

-            // We are lacking a way to signal that the secret has been received, so we wait a bit..
-            jest.useRealTimers();
-            await new Promise((resolve) => {
-                setTimeout(resolve, 500);
-            });
-            jest.useFakeTimers({ doNotFake: ["queueMicrotask"] });
-
            // the backup secret should not be cached
-            const cachedKey = await aliceClient.getCrypto()!.getSessionBackupPrivateKey();
+            const cachedKey = await retrieveBackupPrivateKeyWithDelay();
            expect(cachedKey).toBeNull();
        });

-        newBackendOnly("Should not accept an invalid backup decryption key", async () => {
+        it("Should not accept an invalid backup decryption key", async () => {
            const requestPromises = mockSecretRequestAndGetPromises();

            await doInteractiveVerification();
@@ -1369,6 +1342,15 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st

            await sendBackupGossipAndExpectVersion(requestId!, "InvalidSecret", matchingBackupInfo);

+            // the backup secret should not be cached
+            const cachedKey = await retrieveBackupPrivateKeyWithDelay();
+            expect(cachedKey).toBeNull();
+        });
+
+        /**
+         * Waits briefly for secrets to be gossipped, then fetches the backup private key from the crypto stack.
+         */
+        async function retrieveBackupPrivateKeyWithDelay(): Promise<Uint8Array | null> {
            // We are lacking a way to signal that the secret has been received, so we wait a bit..
            jest.useRealTimers();
            await new Promise((resolve) => {
@@ -1376,19 +1358,22 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
            });
            jest.useFakeTimers({ doNotFake: ["queueMicrotask"] });

-            // the backup secret should not be cached
-            const cachedKey = await aliceClient.getCrypto()!.getSessionBackupPrivateKey();
-            expect(cachedKey).toBeNull();
-        });
+            return aliceClient.getCrypto()!.getSessionBackupPrivateKey();
+        }

        /**
         * Common test setup for gossiping secrets.
         * Creates a peer to peer session, sends the secret, mockup the version API, send the secret back from sync, then await for the backup check.
+         *
+         * @param expectBackup - The result to be returned from the `/room_keys/version` request.
+         * - **KeyBackupInfo**: Indicates a successful request, where the response contains the key backup information (HTTP 200).
+         * - **MatrixError**: Represents an error response from the server, indicating an unsuccessful request (non-200 HTTP status).
+         * - **Error**: Indicates an error during the request process itself (e.g., network issues or unexpected failures).
         */
        async function sendBackupGossipAndExpectVersion(
            requestId: string,
            secret: string,
-            expectBackup: KeyBackupInfo,
+            expectBackup: KeyBackupInfo | MatrixError | Error,
        ) {
            const p2pSession = await createOlmSession(testOlmAccount, e2eKeyReceiver);

@@ -1408,6 +1393,17 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
                    "express:/_matrix/client/v3/room_keys/version",
                    (url, request) => {
                        resolve(undefined);
+                        if (expectBackup instanceof MatrixError) {
+                            return {
+                                status: expectBackup.httpStatus,
+                                body: expectBackup.data,
+                            };
+                        }
+
+                        if (expectBackup instanceof Error) {
+                            return Promise.reject(expectBackup);
+                        }
+
                        return expectBackup;
                    },
                    {
@@ -1482,7 +1478,7 @@ describe.each(Object.entries(CRYPTO_BACKENDS))("verification (%s)", (backend: st
            deviceId: "device_under_test",
            ...opts,
        });
-        await initCrypto(client);
+        await client.initRustCrypto();
        await client.startClient();
        return client;
    }
@@ -1,406 +0,0 @@
-/*
-Copyright 2017 Vector Creations Ltd
-Copyright 2018 New Vector 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.
-*/
-
-import { TestClient } from "../TestClient";
-import * as testUtils from "../test-utils/test-utils";
-import { logger } from "../../src/logger";
-import { KnownMembership } from "../../src/@types/membership";
-
-const ROOM_ID = "!room:id";
-
-/**
- * get a /sync response which contains a single e2e room (ROOM_ID), with the
- * members given
- *
- * @returns sync response
- */
-function getSyncResponse(roomMembers: string[]) {
-    const stateEvents = [
-        testUtils.mkEvent({
-            type: "m.room.encryption",
-            skey: "",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-            },
-        }),
-    ];
-
-    Array.prototype.push.apply(
-        stateEvents,
-        roomMembers.map((m) =>
-            testUtils.mkMembership({
-                mship: KnownMembership.Join,
-                sender: m,
-            }),
-        ),
-    );
-
-    const syncResponse = {
-        next_batch: 1,
-        rooms: {
-            join: {
-                [ROOM_ID]: {
-                    state: {
-                        events: stateEvents,
-                    },
-                },
-            },
-        },
-    };
-
-    return syncResponse;
-}
-
-describe("DeviceList management:", function () {
-    if (!globalThis.Olm) {
-        logger.warn("not running deviceList tests: Olm not present");
-        return;
-    }
-
-    let aliceTestClient: TestClient;
-    let sessionStoreBackend: Storage;
-
-    async function createTestClient() {
-        const testClient = new TestClient("@alice:localhost", "xzcvb", "akjgkrgjs", sessionStoreBackend);
-        await testClient.client.initLegacyCrypto();
-        return testClient;
-    }
-
-    beforeEach(async function () {
-        // we create our own sessionStoreBackend so that we can use it for
-        // another TestClient.
-        sessionStoreBackend = new testUtils.MockStorageApi();
-
-        aliceTestClient = await createTestClient();
-    });
-
-    afterEach(function () {
-        return aliceTestClient.stop();
-    });
-
-    it("Alice shouldn't do a second /query for non-e2e-capable devices", function () {
-        aliceTestClient.expectKeyQuery({
-            device_keys: { "@alice:localhost": {} },
-            failures: {},
-        });
-        return aliceTestClient
-            .start()
-            .then(function () {
-                const syncResponse = getSyncResponse(["@bob:xyz"]);
-                aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
-
-                return aliceTestClient.flushSync();
-            })
-            .then(function () {
-                logger.log("Forcing alice to download our device keys");
-
-                aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, {
-                    device_keys: {
-                        "@bob:xyz": {},
-                    },
-                });
-
-                return Promise.all([
-                    aliceTestClient.client.downloadKeys(["@bob:xyz"]),
-                    aliceTestClient.httpBackend.flush("/keys/query", 1),
-                ]);
-            })
-            .then(function () {
-                logger.log("Telling alice to send a megolm message");
-
-                aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, {
-                    event_id: "$event_id",
-                });
-
-                return Promise.all([
-                    aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
-
-                    // the crypto stuff can take a while, so give the requests a whole second.
-                    aliceTestClient.httpBackend.flushAllExpected({
-                        timeout: 1000,
-                    }),
-                ]);
-            });
-    });
-
-    it.skip("We should not get confused by out-of-order device query responses", () => {
-        // https://github.com/vector-im/element-web/issues/3126
-        aliceTestClient.expectKeyQuery({
-            device_keys: { "@alice:localhost": {} },
-            failures: {},
-        });
-        return aliceTestClient
-            .start()
-            .then(() => {
-                aliceTestClient.httpBackend
-                    .when("GET", "/sync")
-                    .respond(200, getSyncResponse(["@bob:xyz", "@chris:abc"]));
-                return aliceTestClient.flushSync();
-            })
-            .then(() => {
-                // to make sure the initial device queries are flushed out, we
-                // attempt to send a message.
-
-                aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, {
-                    device_keys: {
-                        "@bob:xyz": {},
-                        "@chris:abc": {},
-                    },
-                });
-
-                aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, { event_id: "$event1" });
-
-                return Promise.all([
-                    aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
-                    aliceTestClient.httpBackend
-                        .flush("/keys/query", 1)
-                        .then(() => aliceTestClient.httpBackend.flush("/send/", 1)),
-                    aliceTestClient.client.crypto!.deviceList.saveIfDirty(),
-                ]);
-            })
-            .then(() => {
-                // @ts-ignore accessing a protected field
-                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                    expect(data!.syncToken).toEqual(1);
-                });
-
-                // invalidate bob's and chris's device lists in separate syncs
-                aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-                    next_batch: "2",
-                    device_lists: {
-                        changed: ["@bob:xyz"],
-                    },
-                });
-                aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-                    next_batch: "3",
-                    device_lists: {
-                        changed: ["@chris:abc"],
-                    },
-                });
-                // flush both syncs
-                return aliceTestClient.flushSync().then(() => {
-                    return aliceTestClient.flushSync();
-                });
-            })
-            .then(() => {
-                // check that we don't yet have a request for chris's devices.
-                aliceTestClient.httpBackend
-                    .when("POST", "/keys/query", {
-                        device_keys: {
-                            "@chris:abc": {},
-                        },
-                        token: "3",
-                    })
-                    .respond(200, {
-                        device_keys: { "@chris:abc": {} },
-                    });
-                return aliceTestClient.httpBackend.flush("/keys/query", 1);
-            })
-            .then((flushed) => {
-                expect(flushed).toEqual(0);
-                return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-            })
-            .then(() => {
-                // @ts-ignore accessing a protected field
-                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus["@bob:xyz"];
-                    if (bobStat != 1 && bobStat != 2) {
-                        throw new Error("Unexpected status for bob: wanted 1 or 2, got " + bobStat);
-                    }
-                    const chrisStat = data!.trackingStatus["@chris:abc"];
-                    if (chrisStat != 1 && chrisStat != 2) {
-                        throw new Error("Unexpected status for chris: wanted 1 or 2, got " + chrisStat);
-                    }
-                });
-
-                // now add an expectation for a query for bob's devices, and let
-                // it complete.
-                aliceTestClient.httpBackend
-                    .when("POST", "/keys/query", {
-                        device_keys: {
-                            "@bob:xyz": {},
-                        },
-                        token: "2",
-                    })
-                    .respond(200, {
-                        device_keys: { "@bob:xyz": {} },
-                    });
-                return aliceTestClient.httpBackend.flush("/keys/query", 1);
-            })
-            .then((flushed) => {
-                expect(flushed).toEqual(1);
-
-                // wait for the client to stop processing the response
-                return aliceTestClient.client.downloadKeys(["@bob:xyz"]);
-            })
-            .then(() => {
-                return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-            })
-            .then(() => {
-                // @ts-ignore accessing a protected field
-                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus["@bob:xyz"];
-                    expect(bobStat).toEqual(3);
-                    const chrisStat = data!.trackingStatus["@chris:abc"];
-                    if (chrisStat != 1 && chrisStat != 2) {
-                        throw new Error("Unexpected status for chris: wanted 1 or 2, got " + bobStat);
-                    }
-                });
-
-                // now let the query for chris's devices complete.
-                return aliceTestClient.httpBackend.flush("/keys/query", 1);
-            })
-            .then((flushed) => {
-                expect(flushed).toEqual(1);
-
-                // wait for the client to stop processing the response
-                return aliceTestClient.client.downloadKeys(["@chris:abc"]);
-            })
-            .then(() => {
-                return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-            })
-            .then(() => {
-                // @ts-ignore accessing a protected field
-                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus["@bob:xyz"];
-                    const chrisStat = data!.trackingStatus["@bob:xyz"];
-
-                    expect(bobStat).toEqual(3);
-                    expect(chrisStat).toEqual(3);
-                    expect(data!.syncToken).toEqual(3);
-                });
-            });
-    });
-
-    // https://github.com/vector-im/element-web/issues/4983
-    describe("Alice should know she has stale device lists", () => {
-        beforeEach(async function () {
-            await aliceTestClient.start();
-
-            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse(["@bob:xyz"]));
-            await aliceTestClient.flushSync();
-
-            aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, {
-                device_keys: {
-                    "@bob:xyz": {},
-                },
-            });
-            await aliceTestClient.httpBackend.flush("/keys/query", 1);
-            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus["@bob:xyz"];
-
-                // Alice should be tracking bob's device list
-                expect(bobStat).toBeGreaterThan(0);
-            });
-        });
-
-        it("when Bob leaves", async function () {
-            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: 2,
-                device_lists: {
-                    left: ["@bob:xyz"],
-                },
-                rooms: {
-                    join: {
-                        [ROOM_ID]: {
-                            timeline: {
-                                events: [
-                                    testUtils.mkMembership({
-                                        mship: KnownMembership.Leave,
-                                        sender: "@bob:xyz",
-                                    }),
-                                ],
-                            },
-                        },
-                    },
-                },
-            });
-
-            await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus["@bob:xyz"];
-
-                // Alice should have marked bob's device list as untracked
-                expect(bobStat).toEqual(0);
-            });
-        });
-
-        it("when Alice leaves", async function () {
-            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: 2,
-                device_lists: {
-                    left: ["@bob:xyz"],
-                },
-                rooms: {
-                    leave: {
-                        [ROOM_ID]: {
-                            timeline: {
-                                events: [
-                                    testUtils.mkMembership({
-                                        mship: KnownMembership.Leave,
-                                        sender: "@bob:xyz",
-                                    }),
-                                ],
-                            },
-                        },
-                    },
-                },
-            });
-
-            await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus["@bob:xyz"];
-
-                // Alice should have marked bob's device list as untracked
-                expect(bobStat).toEqual(0);
-            });
-        });
-
-        it("when Bob leaves whilst Alice is offline", async function () {
-            aliceTestClient.stop();
-
-            const anotherTestClient = await createTestClient();
-
-            try {
-                await anotherTestClient.start();
-                anotherTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse([]));
-                await anotherTestClient.flushSync();
-                await anotherTestClient.client?.crypto?.deviceList?.saveIfDirty();
-
-                // @ts-ignore accessing private property
-                anotherTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus["@bob:xyz"];
-
-                    // Alice should have marked bob's device list as untracked
-                    expect(bobStat).toEqual(0);
-                });
-            } finally {
-                anotherTestClient.stop();
-            }
-        });
-    });
-});
@@ -14,13 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import HttpBackend from "matrix-mock-request";
-
+import type HttpBackend from "matrix-mock-request";
 import {
    ClientEvent,
    HttpApiEvent,
-    IEvent,
-    MatrixClient,
+    type IEvent,
+    type MatrixClient,
    RoomEvent,
    RoomMemberEvent,
    RoomStateEvent,
@@ -23,15 +23,15 @@ import {
    EventTimelineSet,
    EventType,
    Filter,
-    IEvent,
-    MatrixClient,
+    type IEvent,
+    type MatrixClient,
    MatrixEvent,
    PendingEventOrdering,
    RelationType,
    Room,
 } from "../../src/matrix";
 import { logger } from "../../src/logger";
-import { encodeParams, encodeUri, QueryDict, replaceParam } from "../../src/utils";
+import { encodeParams, encodeUri, type QueryDict, replaceParam } from "../../src/utils";
 import { TestClient } from "../TestClient";
 import { FeatureSupport, Thread, ThreadEvent } from "../../src/models/thread";
 import { emitPromise } from "../test-utils/test-utils";
@@ -13,28 +13,26 @@ 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 HttpBackend from "matrix-mock-request";
-import { Mocked } from "jest-mock";

+import type HttpBackend from "matrix-mock-request";
 import * as utils from "../test-utils/test-utils";
-import { CRYPTO_ENABLED, IStoredClientOpts, MatrixClient } from "../../src/client";
+import { type IStoredClientOpts, MatrixClient } from "../../src/client";
 import { MatrixEvent } from "../../src/models/event";
 import {
    Filter,
    JoinRule,
-    KnockRoomOpts,
+    type KnockRoomOpts,
    MemoryStore,
    Method,
    Room,
-    RoomSummary,
+    type RoomSummary,
    SERVICE_TYPES,
 } from "../../src/matrix";
 import { TestClient } from "../TestClient";
 import { THREAD_RELATION_TYPE } from "../../src/models/thread";
-import { IFilterDefinition } from "../../src/filter";
-import { ISearchResults } from "../../src/@types/search";
-import { IStore } from "../../src/store";
-import { CryptoBackend } from "../../src/common-crypto/CryptoBackend";
+import { type IFilterDefinition } from "../../src/filter";
+import { type ISearchResults } from "../../src/@types/search";
+import { type IStore } from "../../src/store";
 import { SetPresence } from "../../src/sync";
 import { KnownMembership } from "../../src/@types/membership";

@@ -159,6 +157,30 @@ describe("MatrixClient", function () {
        });
    });

+    describe("mediaConfig", function () {
+        it("should get media config on unauthenticated media call", async () => {
+            httpBackend.when("GET", "/_matrix/media/v3/config").respond(200, '{"m.upload.size": 50000000}', true);
+
+            const prom = client.getMediaConfig();
+
+            httpBackend.flushAllExpected();
+
+            expect((await prom)["m.upload.size"]).toEqual(50000000);
+        });
+
+        it("should get media config on authenticated media call", async () => {
+            httpBackend
+                .when("GET", "/_matrix/client/v1/media/config")
+                .respond(200, '{"m.upload.size": 50000000}', true);
+
+            const prom = client.getMediaConfig(true);
+
+            httpBackend.flushAllExpected();
+
+            expect((await prom)["m.upload.size"]).toEqual(50000000);
+        });
+    });
+
    describe("joinRoom", function () {
        it("should no-op given the ID of a room you've already joined", async () => {
            const roomId = "!foo:bar";
@@ -644,126 +666,6 @@ describe("MatrixClient", function () {
        });
    });

-    describe("downloadKeys", function () {
-        if (!CRYPTO_ENABLED) {
-            return;
-        }
-
-        beforeEach(function () {
-            // running initLegacyCrypto should trigger a key upload
-            httpBackend.when("POST", "/keys/upload").respond(200, {});
-            return Promise.all([client.initLegacyCrypto(), httpBackend.flush("/keys/upload", 1)]);
-        });
-
-        afterEach(() => {
-            client.stopClient();
-        });
-
-        it("should do an HTTP request and then store the keys", function () {
-            const ed25519key = "7wG2lzAqbjcyEkOP7O4gU7ItYcn+chKzh5sT/5r2l78";
-            // ed25519key = client.getDeviceEd25519Key();
-            const borisKeys = {
-                dev1: {
-                    algorithms: ["1"],
-                    device_id: "dev1",
-                    keys: { "ed25519:dev1": ed25519key },
-                    signatures: {
-                        boris: {
-                            "ed25519:dev1":
-                                "RAhmbNDq1efK3hCpBzZDsKoGSsrHUxb25NW5/WbEV9R" +
-                                "JVwLdP032mg5QsKt/pBDUGtggBcnk43n3nBWlA88WAw",
-                        },
-                    },
-                    unsigned: { abc: "def" },
-                    user_id: "boris",
-                },
-            };
-            const chazKeys = {
-                dev2: {
-                    algorithms: ["2"],
-                    device_id: "dev2",
-                    keys: { "ed25519:dev2": ed25519key },
-                    signatures: {
-                        chaz: {
-                            "ed25519:dev2":
-                                "FwslH/Q7EYSb7swDJbNB5PSzcbEO1xRRBF1riuijqvL" +
-                                "EkrK9/XVN8jl4h7thGuRITQ01siBQnNmMK9t45QfcCQ",
-                        },
-                    },
-                    unsigned: { ghi: "def" },
-                    user_id: "chaz",
-                },
-            };
-
-            /*
-            function sign(o) {
-                var anotherjson = require('another-json');
-                var b = JSON.parse(JSON.stringify(o));
-                delete(b.signatures);
-                delete(b.unsigned);
-                return client.crypto.olmDevice.sign(anotherjson.stringify(b));
-            };
-
-            logger.log("Ed25519: " + ed25519key);
-            logger.log("boris:", sign(borisKeys.dev1));
-            logger.log("chaz:", sign(chazKeys.dev2));
-            */
-
-            httpBackend
-                .when("POST", "/keys/query")
-                .check(function (req) {
-                    expect(req.data).toEqual({
-                        device_keys: {
-                            boris: [],
-                            chaz: [],
-                        },
-                    });
-                })
-                .respond(200, {
-                    device_keys: {
-                        boris: borisKeys,
-                        chaz: chazKeys,
-                    },
-                });
-
-            const prom = client.downloadKeys(["boris", "chaz"]).then(function (res) {
-                assertObjectContains(res.get("boris")!.get("dev1")!, {
-                    verified: 0, // DeviceVerification.UNVERIFIED
-                    keys: { "ed25519:dev1": ed25519key },
-                    algorithms: ["1"],
-                    unsigned: { abc: "def" },
-                });
-
-                assertObjectContains(res.get("chaz")!.get("dev2")!, {
-                    verified: 0, // DeviceVerification.UNVERIFIED
-                    keys: { "ed25519:dev2": ed25519key },
-                    algorithms: ["2"],
-                    unsigned: { ghi: "def" },
-                });
-            });
-
-            httpBackend.flush("");
-            return prom;
-        });
-    });
-
-    describe("deleteDevice", function () {
-        const auth = { identifier: 1 };
-        it("should pass through an auth dict", function () {
-            httpBackend
-                .when("DELETE", "/_matrix/client/v3/devices/my_device")
-                .check(function (req) {
-                    expect(req.data).toEqual({ auth: auth });
-                })
-                .respond(200);
-
-            const prom = client.deleteDevice("my_device", auth);
-
-            httpBackend.flush("");
-            return prom;
-        });
-    });
-
    describe("partitionThreadedEvents", function () {
        let room: Room;
        beforeEach(() => {
@@ -1628,49 +1530,6 @@ describe("MatrixClient", function () {
        });
    });

-    describe("uploadKeys", () => {
-        // uploadKeys() is a no-op nowadays, so there's not much to test here.
-        it("should complete successfully", async () => {
-            await client.uploadKeys();
-        });
-    });
-
-    describe("getCryptoTrustCrossSignedDevices", () => {
-        it("should throw if e2e is disabled", () => {
-            expect(() => client.getCryptoTrustCrossSignedDevices()).toThrow("End-to-end encryption disabled");
-        });
-
-        it("should proxy to the crypto backend", async () => {
-            const mockBackend = {
-                getTrustCrossSignedDevices: jest.fn().mockReturnValue(true),
-            } as unknown as Mocked<CryptoBackend>;
-            client["cryptoBackend"] = mockBackend;
-
-            expect(client.getCryptoTrustCrossSignedDevices()).toBe(true);
-            mockBackend.getTrustCrossSignedDevices.mockReturnValue(false);
-            expect(client.getCryptoTrustCrossSignedDevices()).toBe(false);
-        });
-    });
-
-    describe("setCryptoTrustCrossSignedDevices", () => {
-        it("should throw if e2e is disabled", () => {
-            expect(() => client.setCryptoTrustCrossSignedDevices(false)).toThrow("End-to-end encryption disabled");
-        });
-
-        it("should proxy to the crypto backend", async () => {
-            const mockBackend = {
-                setTrustCrossSignedDevices: jest.fn(),
-            } as unknown as Mocked<CryptoBackend>;
-            client["cryptoBackend"] = mockBackend;
-
-            client.setCryptoTrustCrossSignedDevices(true);
-            expect(mockBackend.setTrustCrossSignedDevices).toHaveBeenLastCalledWith(true);
-
-            client.setCryptoTrustCrossSignedDevices(false);
-            expect(mockBackend.setTrustCrossSignedDevices).toHaveBeenLastCalledWith(false);
-        });
-    });
-
    describe("setSyncPresence", () => {
        it("should pass calls through to the underlying sync api", () => {
            const setPresence = jest.fn();
@@ -2197,11 +2056,3 @@ const buildEventCreate = () =>
        type: "m.room.create",
        unsigned: { age: 80126105 },
    });
-
-function assertObjectContains(obj: Record<string, any>, expected: any): void {
-    for (const k in expected) {
-        if (expected.hasOwnProperty(k)) {
-            expect(obj[k]).toEqual(expected[k]);
-        }
-    }
-}
@@ -5,7 +5,7 @@ import { ClientEvent, MatrixClient } from "../../src/matrix";
 import { MatrixScheduler } from "../../src/scheduler";
 import { MemoryStore } from "../../src/store/memory";
 import { MatrixError } from "../../src/http-api";
-import { IStore } from "../../src/store";
+import { type IStore } from "../../src/store";
 import { KnownMembership } from "../../src/@types/membership";

 describe("MatrixClient opts", function () {
@@ -15,9 +15,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import HttpBackend from "matrix-mock-request";
-
-import { Direction, MatrixClient, MatrixScheduler } from "../../src/matrix";
+import type HttpBackend from "matrix-mock-request";
+import { Direction, type MatrixClient, MatrixScheduler } from "../../src/matrix";
 import { TestClient } from "../TestClient";

 describe("MatrixClient relations", () => {
@@ -14,9 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import HttpBackend from "matrix-mock-request";
-
-import { EventStatus, MatrixClient, MatrixScheduler, MsgType, RoomEvent } from "../../src/matrix";
+import type HttpBackend from "matrix-mock-request";
+import { EventStatus, type MatrixClient, MatrixScheduler, MsgType, RoomEvent } from "../../src/matrix";
 import { Room } from "../../src/models/room";
 import { TestClient } from "../TestClient";

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

-import HttpBackend from "matrix-mock-request";
-
+import type HttpBackend from "matrix-mock-request";
 import * as utils from "../test-utils/test-utils";
 import { EventStatus } from "../../src/models/event";
 import {
    MatrixError,
    ClientEvent,
-    IEvent,
-    MatrixClient,
+    type IEvent,
+    type MatrixClient,
    RoomEvent,
-    ISyncResponse,
-    IMinimalEvent,
-    IRoomEvent,
-    Room,
+    type ISyncResponse,
+    type IMinimalEvent,
+    type IRoomEvent,
+    type Room,
 } from "../../src";
 import { TestClient } from "../TestClient";
 import { KnownMembership } from "../../src/@types/membership";
@@ -17,7 +17,7 @@ limitations under the License.
 import "fake-indexeddb/auto";
 import fetchMock from "fetch-mock-jest";

-import { MatrixClient, ClientEvent, createClient, SyncState } from "../../src";
+import { type MatrixClient, ClientEvent, createClient, SyncState } from "../../src";

 const makeQueryablePromise = <T = void>(promise: Promise<T>) => {
    let resolved = false;
@@ -16,8 +16,7 @@ limitations under the License.

 import "fake-indexeddb/auto";

-import HttpBackend from "matrix-mock-request";
-
+import type HttpBackend from "matrix-mock-request";
 import {
    EventTimeline,
    MatrixEvent,
@@ -25,16 +24,15 @@ import {
    RoomStateEvent,
    RoomMemberEvent,
    UNSTABLE_MSC2716_MARKER,
-    MatrixClient,
+    type MatrixClient,
    ClientEvent,
-    IndexedDBCryptoStore,
-    ISyncResponse,
-    IRoomEvent,
-    IJoinedRoom,
-    IStateEvent,
-    IMinimalEvent,
+    type ISyncResponse,
+    type IRoomEvent,
+    type IJoinedRoom,
+    type IStateEvent,
+    type IMinimalEvent,
    NotificationCountType,
-    IEphemeral,
+    type IEphemeral,
    Room,
    IndexedDBStore,
    RelationType,
@@ -47,7 +45,7 @@ import * as utils from "../test-utils/test-utils";
 import { TestClient } from "../TestClient";
 import { emitPromise, mkEvent, mkMessage } from "../test-utils/test-utils";
 import { THREAD_RELATION_TYPE } from "../../src/models/thread";
-import { IActionsObject } from "../../src/pushprocessor";
+import { type IActionsObject } from "../../src/pushprocessor";
 import { KnownMembership } from "../../src/@types/membership";

 declare module "../../src/@types/event" {
@@ -2571,9 +2569,8 @@ describe("MatrixClient syncing (IndexedDB version)", () => {
    };

    it("should emit ClientEvent.Room when invited while using indexeddb crypto store", async () => {
-        const idbTestClient = new TestClient(selfUserId, "DEVICE", selfAccessToken, undefined, {
-            cryptoStore: new IndexedDBCryptoStore(globalThis.indexedDB, "tests"),
-        });
+        // rust crypto uses by default indexeddb
+        const idbTestClient = new TestClient(selfUserId, "DEVICE", selfAccessToken);
        const idbHttpBackend = idbTestClient.httpBackend;
        const idbClient = idbTestClient.client;
        idbHttpBackend.when("GET", "/versions").respond(200, {});
@@ -16,14 +16,13 @@ limitations under the License.

 import "fake-indexeddb/auto";

-import HttpBackend from "matrix-mock-request";
-
+import type HttpBackend from "matrix-mock-request";
 import {
    Category,
    ClientEvent,
    EventType,
-    ISyncResponse,
-    MatrixClient,
+    type ISyncResponse,
+    type MatrixClient,
    MatrixEvent,
    NotificationCountType,
    RelationType,
@@ -30,9 +30,9 @@ import { defer } from "../../../src/utils";
 import {
    ClientPrefix,
    DEVICE_CODE_SCOPE,
-    IHttpOpts,
-    IMyDevice,
-    MatrixClient,
+    type IHttpOpts,
+    type IMyDevice,
+    type MatrixClient,
    MatrixError,
    MatrixHttpApi,
 } from "../../../src";
@@ -15,36 +15,42 @@ limitations under the License.
 */

 // eslint-disable-next-line no-restricted-imports
-import MockHttpBackend from "matrix-mock-request";
 import { fail } from "assert";

-import { SlidingSync, SlidingSyncEvent, MSC3575RoomData, SlidingSyncState, Extension } from "../../src/sliding-sync";
-import { TestClient } from "../TestClient";
-import { IRoomEvent, IStateEvent } from "../../src";
+import type MockHttpBackend from "matrix-mock-request";
 import {
-    MatrixClient,
-    MatrixEvent,
+    SlidingSync,
+    SlidingSyncEvent,
+    type MSC3575RoomData,
+    SlidingSyncState,
+    type Extension,
+} from "../../src/sliding-sync";
+import { TestClient } from "../TestClient";
+import { type IRoomEvent, type IStateEvent } from "../../src";
+import {
+    type MatrixClient,
+    type MatrixEvent,
    NotificationCountType,
    JoinRule,
    MatrixError,
    EventType,
-    IPushRules,
+    type IPushRules,
    PushRuleKind,
    TweakName,
    ClientEvent,
    RoomMemberEvent,
    RoomEvent,
-    Room,
-    IRoomTimelineData,
+    type Room,
+    type IRoomTimelineData,
 } from "../../src";
 import { SlidingSyncSdk } from "../../src/sliding-sync-sdk";
-import { SyncApiOptions, SyncState } from "../../src/sync";
-import { IStoredClientOpts } from "../../src";
+import { type SyncApiOptions, SyncState } from "../../src/sync";
+import { type IStoredClientOpts } from "../../src";
 import { logger } from "../../src/logger";
 import { emitPromise } from "../test-utils/test-utils";
 import { defer } from "../../src/utils";
 import { KnownMembership } from "../../src/@types/membership";
-import { SyncCryptoCallbacks } from "../../src/common-crypto/CryptoBackend";
+import { type SyncCryptoCallbacks } from "../../src/common-crypto/CryptoBackend";

 declare module "../../src/@types/event" {
    interface AccountDataEvents {
@@ -643,11 +649,13 @@ describe("SlidingSyncSdk", () => {
            ext = findExtension("e2ee");
        });

-        it("gets enabled on the initial request only", () => {
-            expect(ext.onRequest(true)).toEqual({
+        it("gets enabled all the time", async () => {
+            expect(await ext.onRequest(true)).toEqual({
+                enabled: true,
+            });
+            expect(await ext.onRequest(false)).toEqual({
                enabled: true,
            });
-            expect(ext.onRequest(false)).toEqual(undefined);
        });

        it("can update device lists", () => {
@@ -689,11 +697,13 @@ describe("SlidingSyncSdk", () => {
            ext = findExtension("account_data");
        });

-        it("gets enabled on the initial request only", () => {
-            expect(ext.onRequest(true)).toEqual({
+        it("gets enabled all the time", async () => {
+            expect(await ext.onRequest(true)).toEqual({
+                enabled: true,
+            });
+            expect(await ext.onRequest(false)).toEqual({
                enabled: true,
            });
-            expect(ext.onRequest(false)).toEqual(undefined);
        });

        it("processes global account data", async () => {
@@ -817,8 +827,12 @@ describe("SlidingSyncSdk", () => {
            ext = findExtension("to_device");
        });

-        it("gets enabled with a limit on the initial request only", () => {
-            const reqJson: any = ext.onRequest(true);
+        it("gets enabled all the time", async () => {
+            let reqJson: any = await ext.onRequest(true);
+            expect(reqJson.enabled).toEqual(true);
+            expect(reqJson.limit).toBeGreaterThan(0);
+            expect(reqJson.since).toBeUndefined();
+            reqJson = await ext.onRequest(false);
            expect(reqJson.enabled).toEqual(true);
            expect(reqJson.limit).toBeGreaterThan(0);
            expect(reqJson.since).toBeUndefined();
@@ -829,7 +843,7 @@ describe("SlidingSyncSdk", () => {
                next_batch: "12345",
                events: [],
            });
-            expect(ext.onRequest(false)).toEqual({
+            expect(await ext.onRequest(false)).toMatchObject({
                since: "12345",
            });
        });
@@ -913,11 +927,13 @@ describe("SlidingSyncSdk", () => {
            ext = findExtension("typing");
        });

-        it("gets enabled on the initial request only", () => {
-            expect(ext.onRequest(true)).toEqual({
+        it("gets enabled all the time", async () => {
+            expect(await ext.onRequest(true)).toEqual({
+                enabled: true,
+            });
+            expect(await ext.onRequest(false)).toEqual({
                enabled: true,
            });
-            expect(ext.onRequest(false)).toEqual(undefined);
        });

        it("processes typing notifications", async () => {
@@ -1036,11 +1052,13 @@ describe("SlidingSyncSdk", () => {
            ext = findExtension("receipts");
        });

-        it("gets enabled on the initial request only", () => {
-            expect(ext.onRequest(true)).toEqual({
+        it("gets enabled all the time", async () => {
+            expect(await ext.onRequest(true)).toEqual({
+                enabled: true,
+            });
+            expect(await ext.onRequest(false)).toEqual({
                enabled: true,
            });
-            expect(ext.onRequest(false)).toEqual(undefined);
        });

        it("processes receipts", async () => {
@@ -15,21 +15,20 @@ limitations under the License.
 */

 // eslint-disable-next-line no-restricted-imports
-import EventEmitter from "events";
-import MockHttpBackend from "matrix-mock-request";
-
+import type EventEmitter from "events";
+import type MockHttpBackend from "matrix-mock-request";
 import {
    SlidingSync,
    SlidingSyncState,
    ExtensionState,
    SlidingSyncEvent,
-    Extension,
-    SlidingSyncEventHandlerMap,
-    MSC3575RoomData,
+    type Extension,
+    type SlidingSyncEventHandlerMap,
+    type MSC3575RoomData,
 } from "../../src/sliding-sync";
 import { TestClient } from "../TestClient";
 import { logger } from "../../src/logger";
-import { MatrixClient } from "../../src";
+import { type MatrixClient } from "../../src";

 /**
 * Tests for sliding sync. These tests are broken down into sub-tests which are reliant upon one another.
@@ -42,7 +41,7 @@ describe("SlidingSync", () => {
    const selfUserId = "@alice:localhost";
    const selfAccessToken = "aseukfgwef";
    const proxyBaseUrl = "http://localhost:8008";
-    const syncUrl = proxyBaseUrl + "/_matrix/client/unstable/org.matrix.msc3575/sync";
+    const syncUrl = proxyBaseUrl + "/_matrix/client/unstable/org.matrix.simplified_msc3575/sync";

    // assign client/httpBackend globals
    const setupClient = () => {
@@ -104,8 +103,8 @@ describe("SlidingSync", () => {
            };
            const ext: Extension<any, any> = {
                name: () => "custom_extension",
-                onRequest: (initial) => {
-                    return { initial: initial };
+                onRequest: async (_) => {
+                    return { initial: true };
                },
                onResponse: async (res) => {
                    return;
@@ -144,18 +143,16 @@ describe("SlidingSync", () => {
                });
            await httpBackend!.flushAllExpected();

-            // expect nothing but ranges and non-initial extensions to be sent
+            // expect all params to be sent TODO: check MSC4186
            httpBackend!
                .when("POST", syncUrl)
                .check(function (req) {
                    const body = req.data;
                    logger.debug("got ", body);
                    expect(body.room_subscriptions).toBeFalsy();
-                    expect(body.lists["a"]).toEqual({
-                        ranges: [[0, 10]],
-                    });
+                    expect(body.lists["a"]).toEqual(listInfo);
                    expect(body.extensions).toBeTruthy();
-                    expect(body.extensions["custom_extension"]).toEqual({ initial: false });
+                    expect(body.extensions["custom_extension"]).toEqual({ initial: true });
                    expect(req.queryParams!["pos"]).toEqual("11");
                })
                .respond(200, function () {
@@ -333,6 +330,7 @@ describe("SlidingSync", () => {
            await p;
        });

+        // TODO: this does not exist in MSC4186
        it("should be able to unsubscribe from a room", async () => {
            httpBackend!
                .when("POST", syncUrl)
@@ -390,18 +388,19 @@ describe("SlidingSync", () => {
            [3, 5],
        ];

+        // request first 3 rooms
+        const listReq = {
+            ranges: [[0, 2]],
+            sort: ["by_name"],
+            timeline_limit: 1,
+            required_state: [["m.room.topic", ""]],
+            filters: {
+                is_dm: true,
+            },
+        };
+
        let slidingSync: SlidingSync;
        it("should be possible to subscribe to a list", async () => {
-            // request first 3 rooms
-            const listReq = {
-                ranges: [[0, 2]],
-                sort: ["by_name"],
-                timeline_limit: 1,
-                required_state: [["m.room.topic", ""]],
-                filters: {
-                    is_dm: true,
-                },
-            };
            slidingSync = new SlidingSync(proxyBaseUrl, new Map([["a", listReq]]), {}, client!, 1);
            httpBackend!
                .when("POST", syncUrl)
@@ -453,11 +452,6 @@ describe("SlidingSync", () => {
            expect(slidingSync.getListData("b")).toBeNull();
            const syncData = slidingSync.getListData("a")!;
            expect(syncData.joinedCount).toEqual(500); // from previous test
-            expect(syncData.roomIndexToRoomId).toEqual({
-                0: roomA,
-                1: roomB,
-                2: roomC,
-            });
        });

        it("should be possible to adjust list ranges", async () => {
@@ -468,10 +462,9 @@ describe("SlidingSync", () => {
                    const body = req.data;
                    logger.log("next ranges", body.lists["a"].ranges);
                    expect(body.lists).toBeTruthy();
-                    expect(body.lists["a"]).toEqual({
-                        // only the ranges should be sent as the rest are unchanged and sticky
-                        ranges: newRanges,
-                    });
+                    // list range should be changed
+                    listReq.ranges = newRanges;
+                    expect(body.lists["a"]).toEqual(listReq); // resend all values TODO: check MSC4186
                })
                .respond(200, {
                    pos: "b",
@@ -496,7 +489,9 @@ describe("SlidingSync", () => {
            await httpBackend!.flushAllExpected();
            await responseProcessed;
            // setListRanges for an invalid list key returns an error
-            await expect(slidingSync.setListRanges("idontexist", newRanges)).rejects.toBeTruthy();
+            expect(() => {
+                slidingSync.setListRanges("idontexist", newRanges);
+            }).toThrow();
        });

        it("should be possible to add an extra list", async () => {
@@ -514,10 +509,7 @@ describe("SlidingSync", () => {
                    const body = req.data;
                    logger.log("extra list", body);
                    expect(body.lists).toBeTruthy();
-                    expect(body.lists["a"]).toEqual({
-                        // only the ranges should be sent as the rest are unchanged and sticky
-                        ranges: newRanges,
-                    });
+                    expect(body.lists["a"]).toEqual(listReq); // resend all values TODO: check MSC4186
                    expect(body.lists["b"]).toEqual(extraListReq);
                })
                .respond(200, {
@@ -538,16 +530,6 @@ describe("SlidingSync", () => {
                        },
                    },
                });
-            listenUntil(slidingSync, "SlidingSync.List", (listKey, joinedCount, roomIndexToRoomId) => {
-                expect(listKey).toEqual("b");
-                expect(joinedCount).toEqual(50);
-                expect(roomIndexToRoomId).toEqual({
-                    0: roomA,
-                    1: roomB,
-                    2: roomC,
-                });
-                return true;
-            });
            const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                return state === SlidingSyncState.Complete;
            });
@@ -555,706 +537,6 @@ describe("SlidingSync", () => {
            await httpBackend!.flushAllExpected();
            await responseProcessed;
        });
-
-        it("should be possible to get list DELETE/INSERTs", async () => {
-            // move C (2) to A (0)
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "e",
-                lists: {
-                    a: {
-                        count: 500,
-                        ops: [
-                            {
-                                op: "DELETE",
-                                index: 2,
-                            },
-                            {
-                                op: "INSERT",
-                                index: 0,
-                                room_id: roomC,
-                            },
-                        ],
-                    },
-                    b: {
-                        count: 50,
-                    },
-                },
-            });
-            let listPromise = listenUntil(
-                slidingSync,
-                "SlidingSync.List",
-                (listKey, joinedCount, roomIndexToRoomId) => {
-                    expect(listKey).toEqual("a");
-                    expect(joinedCount).toEqual(500);
-                    expect(roomIndexToRoomId).toEqual({
-                        0: roomC,
-                        1: roomA,
-                        2: roomB,
-                    });
-                    return true;
-                },
-            );
-            let responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
-                return state === SlidingSyncState.Complete;
-            });
-            await httpBackend!.flushAllExpected();
-            await responseProcessed;
-            await listPromise;
-
-            // move C (0) back to A (2)
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "f",
-                lists: {
-                    a: {
-                        count: 500,
-                        ops: [
-                            {
-                                op: "DELETE",
-                                index: 0,
-                            },
-                            {
-                                op: "INSERT",
-                                index: 2,
-                                room_id: roomC,
-                            },
-                        ],
-                    },
-                    b: {
-                        count: 50,
-                    },
-                },
-            });
-            listPromise = listenUntil(slidingSync, "SlidingSync.List", (listKey, joinedCount, roomIndexToRoomId) => {
-                expect(listKey).toEqual("a");
-                expect(joinedCount).toEqual(500);
-                expect(roomIndexToRoomId).toEqual({
-                    0: roomA,
-                    1: roomB,
-                    2: roomC,
-                });
-                return true;
-            });
-            responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
-                return state === SlidingSyncState.Complete;
-            });
-            await httpBackend!.flushAllExpected();
-            await responseProcessed;
-            await listPromise;
-        });
-
-        it("should ignore invalid list indexes", async () => {
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "e",
-                lists: {
-                    a: {
-                        count: 500,
-                        ops: [
-                            {
-                                op: "DELETE",
-                                index: 2324324,
-                            },
-                        ],
-                    },
-                    b: {
-                        count: 50,
-                    },
-                },
-            });
-            const listPromise = listenUntil(
-                slidingSync,
-                "SlidingSync.List",
-                (listKey, joinedCount, roomIndexToRoomId) => {
-                    expect(listKey).toEqual("a");
-                    expect(joinedCount).toEqual(500);
-                    expect(roomIndexToRoomId).toEqual({
-                        0: roomA,
-                        1: roomB,
-                        2: roomC,
-                    });
-                    return true;
-                },
-            );
-            const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
-                return state === SlidingSyncState.Complete;
-            });
-            await httpBackend!.flushAllExpected();
-            await responseProcessed;
-            await listPromise;
-        });
-
-        it("should be possible to update a list", async () => {
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "g",
-                lists: {
-                    a: {
-                        count: 42,
-                        ops: [
-                            {
-                                op: "INVALIDATE",
-                                range: [0, 2],
-                            },
-                            {
-                                op: "SYNC",
-                                range: [0, 1],
-                                room_ids: [roomB, roomC],
-                            },
-                        ],
-                    },
-                    b: {
-                        count: 50,
-                    },
-                },
-            });
-            // update the list with a new filter
-            slidingSync.setList("a", {
-                filters: {
-                    is_encrypted: true,
-                },
-                ranges: [[0, 100]],
-            });
-            const listPromise = listenUntil(
-                slidingSync,
-                "SlidingSync.List",
-                (listKey, joinedCount, roomIndexToRoomId) => {
-                    expect(listKey).toEqual("a");
-                    expect(joinedCount).toEqual(42);
-                    expect(roomIndexToRoomId).toEqual({
-                        0: roomB,
-                        1: roomC,
-                    });
-                    return true;
-                },
-            );
-            const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
-                return state === SlidingSyncState.Complete;
-            });
-            await httpBackend!.flushAllExpected();
-            await responseProcessed;
-            await listPromise;
-        });
-
-        // this refers to a set of operations where the end result is no change.
-        it("should handle net zero operations correctly", async () => {
-            const indexToRoomId = {
-                0: roomB,
-                1: roomC,
-            };
-            expect(slidingSync.getListData("a")!.roomIndexToRoomId).toEqual(indexToRoomId);
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "f",
-                // currently the list is [B,C] so we will insert D then immediately delete it
-                lists: {
-                    a: {
-                        count: 500,
-                        ops: [
-                            {
-                                op: "DELETE",
-                                index: 2,
-                            },
-                            {
-                                op: "INSERT",
-                                index: 0,
-                                room_id: roomA,
-                            },
-                            {
-                                op: "DELETE",
-                                index: 0,
-                            },
-                        ],
-                    },
-                    b: {
-                        count: 50,
-                    },
-                },
-            });
-            const listPromise = listenUntil(
-                slidingSync,
-                "SlidingSync.List",
-                (listKey, joinedCount, roomIndexToRoomId) => {
-                    expect(listKey).toEqual("a");
-                    expect(joinedCount).toEqual(500);
-                    expect(roomIndexToRoomId).toEqual(indexToRoomId);
-                    return true;
-                },
-            );
-            const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
-                return state === SlidingSyncState.Complete;
-            });
-            await httpBackend!.flushAllExpected();
-            await responseProcessed;
-            await listPromise;
-        });
-
-        it("should handle deletions correctly", async () => {
-            expect(slidingSync.getListData("a")!.roomIndexToRoomId).toEqual({
-                0: roomB,
-                1: roomC,
-            });
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "g",
-                lists: {
-                    a: {
-                        count: 499,
-                        ops: [
-                            {
-                                op: "DELETE",
-                                index: 0,
-                            },
-                        ],
-                    },
-                    b: {
-                        count: 50,
-                    },
-                },
-            });
-            const listPromise = listenUntil(
-                slidingSync,
-                "SlidingSync.List",
-                (listKey, joinedCount, roomIndexToRoomId) => {
-                    expect(listKey).toEqual("a");
-                    expect(joinedCount).toEqual(499);
-                    expect(roomIndexToRoomId).toEqual({
-                        0: roomC,
-                    });
-                    return true;
-                },
-            );
-            const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
-                return state === SlidingSyncState.Complete;
-            });
-            await httpBackend!.flushAllExpected();
-            await responseProcessed;
-            await listPromise;
-        });
-
-        it("should handle insertions correctly", async () => {
-            expect(slidingSync.getListData("a")!.roomIndexToRoomId).toEqual({
-                0: roomC,
-            });
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "h",
-                lists: {
-                    a: {
-                        count: 500,
-                        ops: [
-                            {
-                                op: "INSERT",
-                                index: 1,
-                                room_id: roomA,
-                            },
-                        ],
-                    },
-                    b: {
-                        count: 50,
-                    },
-                },
-            });
-            let listPromise = listenUntil(
-                slidingSync,
-                "SlidingSync.List",
-                (listKey, joinedCount, roomIndexToRoomId) => {
-                    expect(listKey).toEqual("a");
-                    expect(joinedCount).toEqual(500);
-                    expect(roomIndexToRoomId).toEqual({
-                        0: roomC,
-                        1: roomA,
-                    });
-                    return true;
-                },
-            );
-            let responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
-                return state === SlidingSyncState.Complete;
-            });
-            await httpBackend!.flushAllExpected();
-            await responseProcessed;
-            await listPromise;
-
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "h",
-                lists: {
-                    a: {
-                        count: 501,
-                        ops: [
-                            {
-                                op: "INSERT",
-                                index: 1,
-                                room_id: roomB,
-                            },
-                        ],
-                    },
-                    b: {
-                        count: 50,
-                    },
-                },
-            });
-            listPromise = listenUntil(slidingSync, "SlidingSync.List", (listKey, joinedCount, roomIndexToRoomId) => {
-                expect(listKey).toEqual("a");
-                expect(joinedCount).toEqual(501);
-                expect(roomIndexToRoomId).toEqual({
-                    0: roomC,
-                    1: roomB,
-                    2: roomA,
-                });
-                return true;
-            });
-            responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
-                return state === SlidingSyncState.Complete;
-            });
-            await httpBackend!.flushAllExpected();
-            await responseProcessed;
-            await listPromise;
-            slidingSync.stop();
-        });
-
-        // Regression test to make sure things like DELETE 0 INSERT 0 work correctly and we don't
-        // end up losing room IDs.
-        it("should handle insertions with a spurious DELETE correctly", async () => {
-            slidingSync = new SlidingSync(
-                proxyBaseUrl,
-                new Map([
-                    [
-                        "a",
-                        {
-                            ranges: [[0, 20]],
-                        },
-                    ],
-                ]),
-                {},
-                client!,
-                1,
-            );
-            // initially start with nothing
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "a",
-                lists: {
-                    a: {
-                        count: 0,
-                        ops: [],
-                    },
-                },
-            });
-            slidingSync.start();
-            await httpBackend!.flushAllExpected();
-            expect(slidingSync.getListData("a")!.roomIndexToRoomId).toEqual({});
-
-            // insert a room
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "b",
-                lists: {
-                    a: {
-                        count: 1,
-                        ops: [
-                            {
-                                op: "DELETE",
-                                index: 0,
-                            },
-                            {
-                                op: "INSERT",
-                                index: 0,
-                                room_id: roomA,
-                            },
-                        ],
-                    },
-                },
-            });
-            await httpBackend!.flushAllExpected();
-            expect(slidingSync.getListData("a")!.roomIndexToRoomId).toEqual({
-                0: roomA,
-            });
-
-            // insert another room
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "c",
-                lists: {
-                    a: {
-                        count: 1,
-                        ops: [
-                            {
-                                op: "DELETE",
-                                index: 1,
-                            },
-                            {
-                                op: "INSERT",
-                                index: 0,
-                                room_id: roomB,
-                            },
-                        ],
-                    },
-                },
-            });
-            await httpBackend!.flushAllExpected();
-            expect(slidingSync.getListData("a")!.roomIndexToRoomId).toEqual({
-                0: roomB,
-                1: roomA,
-            });
-
-            // insert a final room
-            httpBackend!.when("POST", syncUrl).respond(200, {
-                pos: "c",
-                lists: {
-                    a: {
-                        count: 1,
-                        ops: [
-                            {
-                                op: "DELETE",
-                                index: 2,
-                            },
-                            {
-                                op: "INSERT",
-                                index: 0,
-                                room_id: roomC,
-                            },
-                        ],
-                    },
-                },
-            });
-            await httpBackend!.flushAllExpected();
-            expect(slidingSync.getListData("a")!.roomIndexToRoomId).toEqual({
-                0: roomC,
-                1: roomB,
-                2: roomA,
-            });
-            slidingSync.stop();
-        });
-    });
-
-    describe("transaction IDs", () => {
-        beforeAll(setupClient);
-        afterAll(teardownClient);
-        const roomId = "!foo:bar";
-
-        let slidingSync: SlidingSync;
-
-        // really this applies to them all but it's easier to just test one
-        it("should resolve modifyRoomSubscriptions after SlidingSync.start() is called", async () => {
-            const roomSubInfo = {
-                timeline_limit: 1,
-                required_state: [["m.room.name", ""]],
-            };
-            // add the subscription
-            slidingSync = new SlidingSync(proxyBaseUrl, new Map(), roomSubInfo, client!, 1);
-            // modification before SlidingSync.start()
-            const subscribePromise = slidingSync.modifyRoomSubscriptions(new Set([roomId]));
-            let txnId: string | undefined;
-            httpBackend!
-                .when("POST", syncUrl)
-                .check(function (req) {
-                    const body = req.data;
-                    logger.debug("got ", body);
-                    expect(body.room_subscriptions).toBeTruthy();
-                    expect(body.room_subscriptions[roomId]).toEqual(roomSubInfo);
-                    expect(body.txn_id).toBeTruthy();
-                    txnId = body.txn_id;
-                })
-                .respond(200, function () {
-                    return {
-                        pos: "aaa",
-                        txn_id: txnId,
-                        lists: {},
-                        extensions: {},
-                        rooms: {
-                            [roomId]: {
-                                name: "foo bar",
-                                required_state: [],
-                                timeline: [],
-                            },
-                        },
-                    };
-                });
-            slidingSync.start();
-            await httpBackend!.flushAllExpected();
-            await subscribePromise;
-        });
-        it("should resolve setList during a connection", async () => {
-            const newList = {
-                ranges: [[0, 20]],
-            };
-            const promise = slidingSync.setList("a", newList);
-            let txnId: string | undefined;
-            httpBackend!
-                .when("POST", syncUrl)
-                .check(function (req) {
-                    const body = req.data;
-                    logger.debug("got ", body);
-                    expect(body.room_subscriptions).toBeFalsy();
-                    expect(body.lists["a"]).toEqual(newList);
-                    expect(body.txn_id).toBeTruthy();
-                    txnId = body.txn_id;
-                })
-                .respond(200, function () {
-                    return {
-                        pos: "bbb",
-                        txn_id: txnId,
-                        lists: { a: { count: 5 } },
-                        extensions: {},
-                    };
-                });
-            await httpBackend!.flushAllExpected();
-            await promise;
-            expect(txnId).toBeDefined();
-        });
-        it("should resolve setListRanges during a connection", async () => {
-            const promise = slidingSync.setListRanges("a", [[20, 40]]);
-            let txnId: string | undefined;
-            httpBackend!
-                .when("POST", syncUrl)
-                .check(function (req) {
-                    const body = req.data;
-                    logger.debug("got ", body);
-                    expect(body.room_subscriptions).toBeFalsy();
-                    expect(body.lists["a"]).toEqual({
-                        ranges: [[20, 40]],
-                    });
-                    expect(body.txn_id).toBeTruthy();
-                    txnId = body.txn_id;
-                })
-                .respond(200, function () {
-                    return {
-                        pos: "ccc",
-                        txn_id: txnId,
-                        lists: { a: { count: 5 } },
-                        extensions: {},
-                    };
-                });
-            await httpBackend!.flushAllExpected();
-            await promise;
-            expect(txnId).toBeDefined();
-        });
-        it("should resolve modifyRoomSubscriptionInfo during a connection", async () => {
-            const promise = slidingSync.modifyRoomSubscriptionInfo({
-                timeline_limit: 99,
-            });
-            let txnId: string | undefined;
-            httpBackend!
-                .when("POST", syncUrl)
-                .check(function (req) {
-                    const body = req.data;
-                    logger.debug("got ", body);
-                    expect(body.room_subscriptions).toBeTruthy();
-                    expect(body.room_subscriptions[roomId]).toEqual({
-                        timeline_limit: 99,
-                    });
-                    expect(body.txn_id).toBeTruthy();
-                    txnId = body.txn_id;
-                })
-                .respond(200, function () {
-                    return {
-                        pos: "ddd",
-                        txn_id: txnId,
-                        extensions: {},
-                    };
-                });
-            await httpBackend!.flushAllExpected();
-            await promise;
-            expect(txnId).toBeDefined();
-        });
-        it("should reject earlier pending promises if a later transaction is acknowledged", async () => {
-            // i.e if we have [A,B,C] and see txn_id=C then A,B should be rejected.
-            const gotTxnIds: any[] = [];
-            const pushTxn = function (req: MockHttpBackend["requests"][0]) {
-                gotTxnIds.push(req.data.txn_id);
-            };
-            const failPromise = slidingSync.setListRanges("a", [[20, 40]]);
-            httpBackend!.when("POST", syncUrl).check(pushTxn).respond(200, { pos: "e" }); // missing txn_id
-            await httpBackend!.flushAllExpected();
-            const failPromise2 = slidingSync.setListRanges("a", [[60, 70]]);
-            httpBackend!.when("POST", syncUrl).check(pushTxn).respond(200, { pos: "f" }); // missing txn_id
-            await httpBackend!.flushAllExpected();
-
-            const okPromise = slidingSync.setListRanges("a", [[0, 20]]);
-            let txnId: string | undefined;
-            httpBackend!
-                .when("POST", syncUrl)
-                .check((req) => {
-                    txnId = req.data.txn_id;
-                })
-                .respond(200, () => {
-                    // include the txn_id, earlier requests should now be reject()ed.
-                    return {
-                        pos: "g",
-                        txn_id: txnId,
-                    };
-                });
-            await Promise.all([
-                expect(failPromise).rejects.toEqual(gotTxnIds[0]),
-                expect(failPromise2).rejects.toEqual(gotTxnIds[1]),
-                httpBackend!.flushAllExpected(),
-                okPromise,
-            ]);
-
-            expect(txnId).toBeDefined();
-        });
-        it("should not reject later pending promises if an earlier transaction is acknowledged", async () => {
-            // i.e if we have [A,B,C] and see txn_id=B then C should not be rejected but A should.
-            const gotTxnIds: any[] = [];
-            const pushTxn = function (req: MockHttpBackend["requests"][0]) {
-                gotTxnIds.push(req.data?.txn_id);
-            };
-            const A = slidingSync.setListRanges("a", [[20, 40]]);
-            httpBackend!.when("POST", syncUrl).check(pushTxn).respond(200, { pos: "A" });
-            await httpBackend!.flushAllExpected();
-            const B = slidingSync.setListRanges("a", [[60, 70]]);
-            httpBackend!.when("POST", syncUrl).check(pushTxn).respond(200, { pos: "B" }); // missing txn_id
-            await httpBackend!.flushAllExpected();
-
-            // attach rejection handlers now else if we do it later Jest treats that as an unhandled rejection
-            // which is a fail.
-
-            const C = slidingSync.setListRanges("a", [[0, 20]]);
-            let pendingC = true;
-            C.finally(() => {
-                pendingC = false;
-            });
-            httpBackend!
-                .when("POST", syncUrl)
-                .check(pushTxn)
-                .respond(200, () => {
-                    // include the txn_id for B, so C's promise is outstanding
-                    return {
-                        pos: "C",
-                        txn_id: gotTxnIds[1],
-                    };
-                });
-            await Promise.all([
-                expect(A).rejects.toEqual(gotTxnIds[0]),
-                httpBackend!.flushAllExpected(),
-                // A is rejected, see above
-                expect(B).resolves.toEqual(gotTxnIds[1]), // B is resolved
-            ]);
-            expect(pendingC).toBe(true); // C is pending still
-        });
-        it("should do nothing for unknown txn_ids", async () => {
-            const promise = slidingSync.setListRanges("a", [[20, 40]]);
-            let pending = true;
-            promise.finally(() => {
-                pending = false;
-            });
-            let txnId: string | undefined;
-            httpBackend!
-                .when("POST", syncUrl)
-                .check(function (req) {
-                    const body = req.data;
-                    logger.debug("got ", body);
-                    expect(body.room_subscriptions).toBeFalsy();
-                    expect(body.lists["a"]).toEqual({
-                        ranges: [[20, 40]],
-                    });
-                    expect(body.txn_id).toBeTruthy();
-                    txnId = body.txn_id;
-                })
-                .respond(200, function () {
-                    return {
-                        pos: "ccc",
-                        txn_id: "bogus transaction id",
-                        lists: { a: { count: 5 } },
-                        extensions: {},
-                    };
-                });
-            await httpBackend!.flushAllExpected();
-            expect(txnId).toBeDefined();
-            expect(pending).toBe(true);
-            slidingSync.stop();
-        });
    });

    describe("custom room subscriptions", () => {
@@ -1544,7 +826,7 @@ describe("SlidingSync", () => {

        const extPre: Extension<any, any> = {
            name: () => preExtName,
-            onRequest: (initial) => {
+            onRequest: async (initial) => {
                return onPreExtensionRequest(initial);
            },
            onResponse: (res) => {
@@ -1554,7 +836,7 @@ describe("SlidingSync", () => {
        };
        const extPost: Extension<any, any> = {
            name: () => postExtName,
-            onRequest: (initial) => {
+            onRequest: async (initial) => {
                return onPostExtensionRequest(initial);
            },
            onResponse: (res) => {
@@ -1569,7 +851,7 @@ describe("SlidingSync", () => {

            const callbackOrder: string[] = [];
            let extensionOnResponseCalled = false;
-            onPreExtensionRequest = () => {
+            onPreExtensionRequest = async () => {
                return extReq;
            };
            onPreExtensionResponse = async (resp) => {
@@ -1609,7 +891,7 @@ describe("SlidingSync", () => {
        });

        it("should be able to send nothing in an extension request/response", async () => {
-            onPreExtensionRequest = () => {
+            onPreExtensionRequest = async () => {
                return undefined;
            };
            let responseCalled = false;
@@ -1644,7 +926,7 @@ describe("SlidingSync", () => {

        it("is possible to register extensions after start() has been called", async () => {
            slidingSync.registerExtension(extPost);
-            onPostExtensionRequest = () => {
+            onPostExtensionRequest = async () => {
                return extReq;
            };
            let responseCalled = false;
@@ -16,19 +16,26 @@ limitations under the License.

 import fetchMock from "fetch-mock-jest";

-import { ISyncResponder } from "./SyncResponder";
+import { type ISyncResponder } from "./SyncResponder";

 /**
- *  An object which intercepts `account_data` get and set requests via fetch-mock.
+ * An object which intercepts `account_data` get and set requests via fetch-mock.
+ *
+ * To use this, call {@link interceptSetAccountData} for each type of account date that should be handled. The updated
+ * account data will be stored in {@link accountDataEvents}; it will also trigger a sync response echoing the updated
+ * data.
+ *
+ * Optionally, you can also call {@link interceptGetAccountData}.
 */
 export class AccountDataAccumulator {
    /**
     * The account data events to be returned by the sync.
     * Will be updated when fetchMock intercepts calls to PUT `/_matrix/client/v3/user/:userId/account_data/`.
-     * Will be used by `sendSyncResponseWithUpdatedAccountData`
     */
    public accountDataEvents: Map<string, any> = new Map();

+    public constructor(private syncResponder: ISyncResponder) {}
+
    /**
     * Intercept requests to set a particular type of account data.
     *
@@ -53,6 +60,9 @@ export class AccountDataAccumulator {
                    // update account data for sync response
                    this.accountDataEvents.set(type!, content);
                    resolve(content);
+
+                    // return a sync response
+                    this.sendSyncResponseWithUpdatedAccountData();
                    return {};
                },
                opts,
@@ -90,9 +100,9 @@ export class AccountDataAccumulator {
    /**
     * Send a sync response the current account data events.
     */
-    public sendSyncResponseWithUpdatedAccountData(syncResponder: ISyncResponder): void {
+    private sendSyncResponseWithUpdatedAccountData(): void {
        try {
-            syncResponder.sendOrQueueSyncResponse({
+            this.syncResponder.sendOrQueueSyncResponse({
                next_batch: 1,
                account_data: {
                    events: Array.from(this.accountDataEvents, ([type, content]) => ({
@@ -15,7 +15,7 @@ limitations under the License.
 */

 import debugFunc from "debug";
-import { Debugger } from "debug";
+import { type Debugger } from "debug";
 import fetchMock from "fetch-mock-jest";

 import type { IDeviceKeys, IOneTimeKey } from "../../src/@types/crypto";
@@ -17,9 +17,9 @@ limitations under the License.
 import fetchMock from "fetch-mock-jest";

 import { MapWithDefault } from "../../src/utils";
-import { IDownloadKeyResult } from "../../src";
-import { IDeviceKeys } from "../../src/@types/crypto";
-import { E2EKeyReceiver } from "./E2EKeyReceiver";
+import { type IDownloadKeyResult } from "../../src";
+import { type IDeviceKeys } from "../../src/@types/crypto";
+import { type E2EKeyReceiver } from "./E2EKeyReceiver";

 /**
 * An object which intercepts `/keys/query` fetches via fetch-mock.
@@ -15,9 +15,10 @@ limitations under the License.
 */

 import debugFunc from "debug";
-import { Debugger } from "debug";
+import { type Debugger } from "debug";
 import fetchMock from "fetch-mock-jest";
-import FetchMock from "fetch-mock";
+
+import type FetchMock from "fetch-mock";

 /** Interface implemented by classes that intercept `/sync` requests from test clients
 *
@@ -16,7 +16,7 @@ limitations under the License.

 import { MatrixEvent } from "../../src";
 import { M_BEACON, M_BEACON_INFO } from "../../src/@types/beacon";
-import { LocationAssetType } from "../../src/@types/location";
+import { type LocationAssetType } from "../../src/@types/location";
 import { makeBeaconContent, makeBeaconInfoContent } from "../../src/content-helpers";

 type InfoContentProps = {
@@ -14,9 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { MethodLikeKeys, mocked, MockedObject } from "jest-mock";
+import { type MethodLikeKeys, mocked, type MockedObject } from "jest-mock";

-import { ClientEventHandlerMap, EmittedEvents, MatrixClient } from "../../src/client";
+import { type ClientEventHandlerMap, type EmittedEvents, type MatrixClient } from "../../src/client";
 import { TypedEventEmitter } from "../../src/models/typed-event-emitter";
 import { User } from "../../src/models/user";

@@ -16,14 +16,15 @@ limitations under the License.

 import fetchMock from "fetch-mock-jest";

-import { KeyBackupInfo } from "../../src/crypto-api";
+import { type KeyBackupInfo } from "../../src/crypto-api";

 /**
 * Mock out the endpoints that the js-sdk calls when we call `MatrixClient.start()`.
 *
 * @param homeserverUrl - the homeserver url for the client under test
+ * @param userId - the local user's ID. Defaults to `@alice:localhost`.
 */
-export function mockInitialApiRequests(homeserverUrl: string) {
+export function mockInitialApiRequests(homeserverUrl: string, userId: string = "@alice:localhost") {
    fetchMock.getOnce(
        new URL("/_matrix/client/versions", homeserverUrl).toString(),
        { versions: ["v1.1"] },
@@ -35,7 +36,7 @@ export function mockInitialApiRequests(homeserverUrl: string) {
        { overwriteRoutes: true },
    );
    fetchMock.postOnce(
-        new URL("/_matrix/client/v3/user/%40alice%3Alocalhost/filter", homeserverUrl).toString(),
+        new URL(`/_matrix/client/v3/user/${encodeURIComponent(userId)}/filter`, homeserverUrl).toString(),
        { filter_id: "fid" },
        { overwriteRoutes: true },
    );
@@ -3,9 +3,9 @@
 * Do not edit by hand! This file is generated by `./generate-test-data.py`
 */

-import { IDeviceKeys, IMegolmSessionData } from "../../../src/@types/crypto";
-import { IDownloadKeyResult, IEvent } from "../../../src";
-import { KeyBackupSession, KeyBackupInfo } from "../../../src/crypto-api/keybackup";
+import { type IDeviceKeys, type IMegolmSessionData } from "../../../src/@types/crypto";
+import { type IDownloadKeyResult, type IEvent } from "../../../src";
+import { type KeyBackupSession, type KeyBackupInfo } from "../../../src/crypto-api/keybackup";

 /* eslint-disable comma-dangle */

@@ -1,25 +1,31 @@
-// eslint-disable-next-line no-restricted-imports
-import EventEmitter from "events";
-
 // load olm before the sdk if possible
 import "../olm-loader";

+// eslint-disable-next-line no-restricted-imports
+import type EventEmitter from "events";
 import { logger } from "../../src/logger";
-import { IContent, IEvent, IEventRelation, IUnsigned, MatrixEvent, MatrixEventEvent } from "../../src/models/event";
+import {
+    type IContent,
+    type IEvent,
+    type IEventRelation,
+    type IUnsigned,
+    MatrixEvent,
+    MatrixEventEvent,
+} from "../../src/models/event";
 import {
    ClientEvent,
    EventType,
-    IJoinedRoom,
-    IPusher,
-    ISyncResponse,
-    MatrixClient,
+    type IJoinedRoom,
+    type IPusher,
+    type ISyncResponse,
+    type MatrixClient,
    MsgType,
    RelationType,
 } from "../../src";
 import { SyncState } from "../../src/sync";
 import { eventMapperFor } from "../../src/event-mapper";
 import { TEST_ROOM_ID } from "./test-data";
-import { KnownMembership, Membership } from "../../src/@types/membership";
+import { KnownMembership, type Membership } from "../../src/@types/membership";

 /**
 * Return a promise that is resolved when the client next emits a
@@ -552,18 +558,6 @@ export const mkPusher = (extra: Partial<IPusher> = {}): IPusher => ({
    ...extra,
 });

-/**
- * a list of the supported crypto implementations, each with a callback to initialise that implementation
- * for the given client
- */
-export const CRYPTO_BACKENDS: Record<string, InitCrypto> = {};
-export type InitCrypto = (_: MatrixClient) => Promise<void>;
-
-CRYPTO_BACKENDS["rust-sdk"] = (client: MatrixClient) => client.initRustCrypto();
-if (globalThis.Olm) {
-    CRYPTO_BACKENDS["libolm"] = (client: MatrixClient) => client.initLegacyCrypto();
-}
-
 export const emitPromise = (e: EventEmitter, k: string): Promise<any> => new Promise((r) => e.once(k, r));

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

-import { DumpDataSetInfo } from "../index";
+import { type DumpDataSetInfo } from "../index";

 /**
 * A key query response containing the current keys of the tested user.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { DumpDataSetInfo } from "../index";
+import { type DumpDataSetInfo } from "../index";

 /**
 * A key query response containing the current keys of the tested user.
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { KeyBackupInfo } from "../../../../src/crypto-api/keybackup";
-import { DumpDataSetInfo } from "../index";
+import { type KeyBackupInfo } from "../../../../src/crypto-api/keybackup";
+import { type DumpDataSetInfo } from "../index";

 /**
 * A key query response containing the current keys of the tested user.
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { DumpDataSetInfo } from "../index";
+import { type DumpDataSetInfo } from "../index";

 /**
 * A key query response containing the current keys of the tested user.
@@ -15,10 +15,10 @@ limitations under the License.
 */

 import { RelationType } from "../../src/@types/event";
-import { MatrixClient } from "../../src/client";
-import { MatrixEvent, MatrixEventEvent } from "../../src/models/event";
-import { Room } from "../../src/models/room";
-import { Thread, THREAD_RELATION_TYPE } from "../../src/models/thread";
+import { type MatrixClient } from "../../src/client";
+import { type MatrixEvent, MatrixEventEvent } from "../../src/models/event";
+import { type Room } from "../../src/models/room";
+import { type Thread, THREAD_RELATION_TYPE } from "../../src/models/thread";
 import { mkMessage } from "./test-utils";

 export const makeThreadEvent = ({
@@ -15,32 +15,33 @@ limitations under the License.
 */

 import {
-    ClientEvent,
-    ClientEventHandlerMap,
+    type ClientEvent,
+    type ClientEventHandlerMap,
+    type EmptyObject,
    EventType,
-    GroupCall,
+    type GroupCall,
    GroupCallIntent,
    GroupCallType,
-    IContent,
-    ISendEventResponse,
-    MatrixClient,
-    MatrixEvent,
-    Room,
+    type IContent,
+    type ISendEventResponse,
+    type MatrixClient,
+    type MatrixEvent,
+    type Room,
    RoomMember,
-    RoomState,
+    type RoomState,
    RoomStateEvent,
-    RoomStateEventHandlerMap,
-    SendToDeviceContentMap,
+    type RoomStateEventHandlerMap,
+    type SendToDeviceContentMap,
 } from "../../src";
 import { TypedEventEmitter } from "../../src/models/typed-event-emitter";
 import { ReEmitter } from "../../src/ReEmitter";
 import { SyncState } from "../../src/sync";
-import { CallEvent, CallEventHandlerMap, CallState, MatrixCall } from "../../src/webrtc/call";
-import { CallEventHandlerEvent, CallEventHandlerEventHandlerMap } from "../../src/webrtc/callEventHandler";
-import { CallFeed } from "../../src/webrtc/callFeed";
-import { GroupCallEventHandlerMap } from "../../src/webrtc/groupCall";
-import { GroupCallEventHandlerEvent } from "../../src/webrtc/groupCallEventHandler";
-import { IScreensharingOpts, MediaHandler } from "../../src/webrtc/mediaHandler";
+import { type CallEvent, type CallEventHandlerMap, CallState, type MatrixCall } from "../../src/webrtc/call";
+import { type CallEventHandlerEvent, type CallEventHandlerEventHandlerMap } from "../../src/webrtc/callEventHandler";
+import { type CallFeed } from "../../src/webrtc/callFeed";
+import { type GroupCallEventHandlerMap } from "../../src/webrtc/groupCall";
+import { type GroupCallEventHandlerEvent } from "../../src/webrtc/groupCallEventHandler";
+import { type IScreensharingOpts, type MediaHandler } from "../../src/webrtc/mediaHandler";

 export const DUMMY_SDP =
    "v=0\r\n" +
@@ -466,7 +467,7 @@ export class MockCallMatrixClient extends TypedEventEmitter<EmittedEvents, Emitt
        [roomId: string, eventType: EventType, content: any, statekey: string]
    >();
    public sendToDevice = jest.fn<
-        Promise<{}>,
+        Promise<EmptyObject>,
        [eventType: string, contentMap: SendToDeviceContentMap, txnId?: string]
    >();

@@ -1,9 +1,9 @@
 import { ConnectionError } from "../../src/http-api/errors";
-import { ClientEvent, MatrixClient, Store } from "../../src/client";
+import { ClientEvent, type MatrixClient, type Store } from "../../src/client";
 import { ToDeviceMessageQueue } from "../../src/ToDeviceMessageQueue";
 import { getMockClientWithEventEmitter } from "../test-utils/client";
 import { StubStore } from "../../src/store/stub";
-import { IndexedToDeviceBatch } from "../../src/models/ToDeviceMessage";
+import { type IndexedToDeviceBatch } from "../../src/models/ToDeviceMessage";
 import { SyncState } from "../../src/sync";
 import { defer } from "../../src/utils";

@@ -1,243 +0,0 @@
-/*
-Copyright 2020 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import "../../olm-loader";
-import { CrossSigningInfo, createCryptoStoreCacheCallbacks } from "../../../src/crypto/CrossSigning";
-import { IndexedDBCryptoStore } from "../../../src/crypto/store/indexeddb-crypto-store";
-import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
-import "fake-indexeddb/auto";
-import "jest-localstorage-mock";
-import { OlmDevice } from "../../../src/crypto/OlmDevice";
-import { logger } from "../../../src/logger";
-
-const userId = "@alice:example.com";
-
-// Private key for tests only
-const testKey = new Uint8Array([
-    0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82, 0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef, 0xae, 0xb1, 0x05,
-    0xc1, 0xe7, 0x62, 0x78, 0xa6, 0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
-]);
-
-const types = [
-    { type: "master", shouldCache: true },
-    { type: "self_signing", shouldCache: true },
-    { type: "user_signing", shouldCache: true },
-    { type: "invalid", shouldCache: false },
-];
-
-const badKey = Uint8Array.from(testKey);
-badKey[0] ^= 1;
-
-const masterKeyPub = "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk";
-
-describe("CrossSigningInfo.getCrossSigningKey", function () {
-    if (!globalThis.Olm) {
-        logger.warn("Not running megolm backup unit tests: libolm not present");
-        return;
-    }
-
-    beforeAll(function () {
-        return globalThis.Olm.init();
-    });
-
-    it("should throw if no callback is provided", async () => {
-        const info = new CrossSigningInfo(userId);
-        await expect(info.getCrossSigningKey("master")).rejects.toThrow();
-    });
-
-    it.each(types)("should throw if the callback returns falsey", async ({ type, shouldCache }) => {
-        const info = new CrossSigningInfo(userId, {
-            getCrossSigningKey: async () => false as unknown as Uint8Array,
-        });
-        await expect(info.getCrossSigningKey(type)).rejects.toThrow("falsey");
-    });
-
-    it("should throw if the expected key doesn't come back", async () => {
-        const info = new CrossSigningInfo(userId, {
-            getCrossSigningKey: async () => masterKeyPub as unknown as Uint8Array,
-        });
-        await expect(info.getCrossSigningKey("master", "")).rejects.toThrow();
-    });
-
-    it("should return a key from its callback", async () => {
-        const info = new CrossSigningInfo(userId, {
-            getCrossSigningKey: async () => testKey,
-        });
-        const [pubKey, pkSigning] = await info.getCrossSigningKey("master", masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-        // check that the pkSigning object corresponds to the pubKey
-        const signature = pkSigning.sign("message");
-        const util = new globalThis.Olm.Utility();
-        try {
-            util.ed25519_verify(pubKey, "message", signature);
-        } finally {
-            util.free();
-        }
-    });
-
-    it.each(types)(
-        "should request a key from the cache callback (if set)" + " and does not call app if one is found" + " %o",
-        async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockImplementation(() => {
-                if (shouldCache) {
-                    return Promise.reject(new Error("Regular callback called"));
-                } else {
-                    return Promise.resolve(testKey);
-                }
-            });
-            const getCrossSigningKeyCache = jest.fn().mockResolvedValue(testKey);
-            const info = new CrossSigningInfo(userId, { getCrossSigningKey }, { getCrossSigningKeyCache });
-            const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-            expect(pubKey).toEqual(masterKeyPub);
-            expect(getCrossSigningKeyCache).toHaveBeenCalledTimes(shouldCache ? 1 : 0);
-            if (shouldCache) {
-                // eslint-disable-next-line jest/no-conditional-expect
-                expect(getCrossSigningKeyCache).toHaveBeenLastCalledWith(type, expect.any(String));
-            }
-        },
-    );
-
-    it.each(types)("should store a key with the cache callback (if set)", async ({ type, shouldCache }) => {
-        const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-        const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-        const info = new CrossSigningInfo(userId, { getCrossSigningKey }, { storeCrossSigningKeyCache });
-        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-        expect(storeCrossSigningKeyCache).toHaveBeenCalledTimes(shouldCache ? 1 : 0);
-        if (shouldCache) {
-            // eslint-disable-next-line jest/no-conditional-expect
-            expect(storeCrossSigningKeyCache).toHaveBeenLastCalledWith(type, testKey);
-        }
-    });
-
-    it.each(types)("does not store a bad key to the cache", async ({ type, shouldCache }) => {
-        const getCrossSigningKey = jest.fn().mockResolvedValue(badKey);
-        const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-        const info = new CrossSigningInfo(userId, { getCrossSigningKey }, { storeCrossSigningKeyCache });
-        await expect(info.getCrossSigningKey(type, masterKeyPub)).rejects.toThrow();
-        expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(0);
-    });
-
-    it.each(types)("does not store a value to the cache if it came from the cache", async ({ type, shouldCache }) => {
-        const getCrossSigningKey = jest.fn().mockImplementation(() => {
-            if (shouldCache) {
-                return Promise.reject(new Error("Regular callback called"));
-            } else {
-                return Promise.resolve(testKey);
-            }
-        });
-        const getCrossSigningKeyCache = jest.fn().mockResolvedValue(testKey);
-        const storeCrossSigningKeyCache = jest.fn().mockRejectedValue(new Error("Tried to store a value from cache"));
-        const info = new CrossSigningInfo(
-            userId,
-            { getCrossSigningKey },
-            { getCrossSigningKeyCache, storeCrossSigningKeyCache },
-        );
-        expect(storeCrossSigningKeyCache.mock.calls.length).toBe(0);
-        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-    });
-
-    it.each(types)(
-        "requests a key from the cache callback (if set) and then calls app" + " if one is not found",
-        async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-            const getCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-            const storeCrossSigningKeyCache = jest.fn();
-            const info = new CrossSigningInfo(
-                userId,
-                { getCrossSigningKey },
-                { getCrossSigningKeyCache, storeCrossSigningKeyCache },
-            );
-            const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-            expect(pubKey).toEqual(masterKeyPub);
-            expect(getCrossSigningKey.mock.calls.length).toBe(1);
-            expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-
-            /* Also expect that the cache gets updated */
-            expect(storeCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-        },
-    );
-
-    it.each(types)(
-        "requests a key from the cache callback (if set) and then" + " calls app if that key doesn't match",
-        async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-            const getCrossSigningKeyCache = jest.fn().mockResolvedValue(badKey);
-            const storeCrossSigningKeyCache = jest.fn();
-            const info = new CrossSigningInfo(
-                userId,
-                { getCrossSigningKey },
-                { getCrossSigningKeyCache, storeCrossSigningKeyCache },
-            );
-            const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-            expect(pubKey).toEqual(masterKeyPub);
-            expect(getCrossSigningKey.mock.calls.length).toBe(1);
-            expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-
-            /* Also expect that the cache gets updated */
-            expect(storeCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-        },
-    );
-});
-
-/*
- * Note that MemoryStore is weird.  It's only used for testing - as far as I can tell,
- * it's not possible to get one in normal execution unless you hack as we do here.
- */
-describe.each([
-    ["IndexedDBCryptoStore", () => new IndexedDBCryptoStore(globalThis.indexedDB, "tests")],
-    ["LocalStorageCryptoStore", () => new IndexedDBCryptoStore(undefined!, "tests")],
-    [
-        "MemoryCryptoStore",
-        () => {
-            const store = new IndexedDBCryptoStore(undefined!, "tests");
-            // @ts-ignore set private properties
-            store._backend = new MemoryCryptoStore();
-            // @ts-ignore
-            store._backendPromise = Promise.resolve(store._backend);
-            return store;
-        },
-    ],
-])("CrossSigning > createCryptoStoreCacheCallbacks [%s]", function (name, dbFactory) {
-    let store: IndexedDBCryptoStore;
-
-    beforeAll(() => {
-        store = dbFactory();
-    });
-
-    beforeEach(async () => {
-        await store.deleteAllData();
-    });
-
-    it("should cache data to the store and retrieve it", async () => {
-        await store.startup();
-        const olmDevice = new OlmDevice(store);
-        const { getCrossSigningKeyCache, storeCrossSigningKeyCache } = createCryptoStoreCacheCallbacks(
-            store,
-            olmDevice,
-        );
-        await storeCrossSigningKeyCache!("self_signing", testKey);
-
-        // If we've not saved anything, don't expect anything
-        // Definitely don't accidentally return the wrong key for the type
-        const nokey = await getCrossSigningKeyCache!("self", "");
-        expect(nokey).toBeNull();
-
-        const key = await getCrossSigningKeyCache!("self_signing", "");
-        expect(new Uint8Array(key!)).toEqual(testKey);
-    });
-});
@@ -1,215 +0,0 @@
-/*
-Copyright 2017 Vector Creations Ltd
-Copyright 2018, 2019 New Vector Ltd
-Copyright 2019, 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-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 "../../../src/logger";
-import * as utils from "../../../src/utils";
-import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
-import { DeviceList } from "../../../src/crypto/DeviceList";
-import { IDownloadKeyResult, MatrixClient } from "../../../src";
-import { OlmDevice } from "../../../src/crypto/OlmDevice";
-import { CryptoStore } from "../../../src/crypto/store/base";
-
-const signedDeviceList: IDownloadKeyResult = {
-    failures: {},
-    device_keys: {
-        "@test1:sw1v.org": {
-            HGKAWHRVJQ: {
-                signatures: {
-                    "@test1:sw1v.org": {
-                        "ed25519:HGKAWHRVJQ":
-                            "8PB450fxKDn5s8IiRZ2N2t6MiueQYVRLHFEzqIi1eLdxx1w" +
-                            "XEPC1/1Uz9T4gwnKlMVAKkhB5hXQA/3kjaeLABw",
-                    },
-                },
-                user_id: "@test1:sw1v.org",
-                keys: {
-                    "ed25519:HGKAWHRVJQ": "0gI/T6C+mn1pjtvnnW2yB2l1IIBb/5ULlBXi/LXFSEQ",
-                    "curve25519:HGKAWHRVJQ": "mbIZED1dBsgIgkgzxDpxKkJmsr4hiWlGzQTvUnQe3RY",
-                },
-                algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
-                device_id: "HGKAWHRVJQ",
-                unsigned: {
-                    device_display_name: "",
-                },
-            },
-        },
-    },
-};
-
-const signedDeviceList2: IDownloadKeyResult = {
-    failures: {},
-    device_keys: {
-        "@test2:sw1v.org": {
-            QJVRHWAKGH: {
-                signatures: {
-                    "@test2:sw1v.org": {
-                        "ed25519:QJVRHWAKGH":
-                            "w1xxdLe1iIqzEFHLRVYQeuiM6t2N2ZRiI8s5nDKxf054BP8" +
-                            "1CPEX/AQXh5BhkKAVMlKnwg4T9zU1/wBALeajk3",
-                    },
-                },
-                user_id: "@test2:sw1v.org",
-                keys: {
-                    "ed25519:QJVRHWAKGH": "Ig0/C6T+bBII1l2By2Wnnvtjp1nm/iXBlLU5/QESFXL",
-                    "curve25519:QJVRHWAKGH": "YR3eQnUvTQzGlWih4rsmJkKxpDxzgkgIgsBd1DEZIbm",
-                },
-                algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
-                device_id: "QJVRHWAKGH",
-                unsigned: {
-                    device_display_name: "",
-                },
-            },
-        },
-    },
-};
-
-describe("DeviceList", function () {
-    let downloadSpy: jest.Mock;
-    let cryptoStore: CryptoStore;
-    let deviceLists: DeviceList[] = [];
-
-    beforeEach(function () {
-        deviceLists = [];
-
-        downloadSpy = jest.fn();
-        cryptoStore = new MemoryCryptoStore();
-    });
-
-    afterEach(function () {
-        for (const dl of deviceLists) {
-            dl.stop();
-        }
-    });
-
-    function createTestDeviceList(keyDownloadChunkSize = 250) {
-        const baseApis = {
-            downloadKeysForUsers: downloadSpy,
-            getUserId: () => "@test1:sw1v.org",
-            deviceId: "HGKAWHRVJQ",
-        } as unknown as MatrixClient;
-        const mockOlm = {
-            verifySignature: function (key: string, message: string, signature: string) {},
-        } as unknown as OlmDevice;
-        const dl = new DeviceList(baseApis, cryptoStore, mockOlm, keyDownloadChunkSize);
-        deviceLists.push(dl);
-        return dl;
-    }
-
-    it("should successfully download and store device keys", function () {
-        const dl = createTestDeviceList();
-
-        dl.startTrackingDeviceList("@test1:sw1v.org");
-
-        const queryDefer1 = utils.defer<IDownloadKeyResult>();
-        downloadSpy.mockReturnValue(queryDefer1.promise);
-
-        const prom1 = dl.refreshOutdatedDeviceLists();
-        expect(downloadSpy).toHaveBeenCalledWith(["@test1:sw1v.org"], {});
-        queryDefer1.resolve(utils.deepCopy(signedDeviceList));
-
-        return prom1.then(() => {
-            const storedKeys = dl.getRawStoredDevicesForUser("@test1:sw1v.org");
-            expect(Object.keys(storedKeys)).toEqual(["HGKAWHRVJQ"]);
-            dl.stop();
-        });
-    });
-
-    it("should have an outdated devicelist on an invalidation while an update is in progress", async function () {
-        const dl = createTestDeviceList();
-
-        dl.startTrackingDeviceList("@test1:sw1v.org");
-
-        const queryDefer1 = utils.defer<IDownloadKeyResult>();
-        downloadSpy.mockReturnValue(queryDefer1.promise);
-
-        const prom1 = dl.refreshOutdatedDeviceLists();
-        expect(downloadSpy).toHaveBeenCalledWith(["@test1:sw1v.org"], {});
-        downloadSpy.mockReset();
-
-        // outdated notif arrives while the request is in flight.
-        const queryDefer2 = utils.defer();
-        downloadSpy.mockReturnValue(queryDefer2.promise);
-
-        dl.invalidateUserDeviceList("@test1:sw1v.org");
-        dl.refreshOutdatedDeviceLists();
-
-        await dl
-            .saveIfDirty()
-            .then(() => {
-                // the first request completes
-                queryDefer1.resolve({
-                    failures: {},
-                    device_keys: {
-                        "@test1:sw1v.org": {},
-                    },
-                });
-                return prom1;
-            })
-            .then(async () => {
-                // uh-oh; user restarts before second request completes. The new instance
-                // should know we never got a complete device list.
-                logger.log("Creating new devicelist to simulate app reload");
-                downloadSpy.mockReset();
-                const dl2 = createTestDeviceList();
-                await dl2.load();
-                const queryDefer3 = utils.defer<IDownloadKeyResult>();
-                downloadSpy.mockReturnValue(queryDefer3.promise);
-
-                const prom3 = dl2.refreshOutdatedDeviceLists();
-                expect(downloadSpy).toHaveBeenCalledWith(["@test1:sw1v.org"], {});
-                dl2.stop();
-
-                queryDefer3.resolve(utils.deepCopy(signedDeviceList));
-
-                // allow promise chain to complete
-                return prom3;
-            })
-            .then(() => {
-                const storedKeys = dl.getRawStoredDevicesForUser("@test1:sw1v.org");
-                expect(Object.keys(storedKeys)).toEqual(["HGKAWHRVJQ"]);
-                dl.stop();
-            });
-    });
-
-    it("should download device keys in batches", function () {
-        const dl = createTestDeviceList(1);
-
-        dl.startTrackingDeviceList("@test1:sw1v.org");
-        dl.startTrackingDeviceList("@test2:sw1v.org");
-
-        const queryDefer1 = utils.defer<IDownloadKeyResult>();
-        downloadSpy.mockReturnValueOnce(queryDefer1.promise);
-        const queryDefer2 = utils.defer<IDownloadKeyResult>();
-        downloadSpy.mockReturnValueOnce(queryDefer2.promise);
-
-        const prom1 = dl.refreshOutdatedDeviceLists();
-        expect(downloadSpy).toHaveBeenCalledTimes(2);
-        expect(downloadSpy).toHaveBeenNthCalledWith(1, ["@test1:sw1v.org"], {});
-        expect(downloadSpy).toHaveBeenNthCalledWith(2, ["@test2:sw1v.org"], {});
-        queryDefer1.resolve(utils.deepCopy(signedDeviceList));
-        queryDefer2.resolve(utils.deepCopy(signedDeviceList2));
-
-        return prom1.then(() => {
-            const storedKeys1 = dl.getRawStoredDevicesForUser("@test1:sw1v.org");
-            expect(Object.keys(storedKeys1)).toEqual(["HGKAWHRVJQ"]);
-            const storedKeys2 = dl.getRawStoredDevicesForUser("@test2:sw1v.org");
-            expect(Object.keys(storedKeys2)).toEqual(["QJVRHWAKGH"]);
-            dl.stop();
-        });
-    });
-});
@@ -1,257 +0,0 @@
-/*
-Copyright 2018,2019 New Vector Ltd
-Copyright 2019, 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-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 { MockedObject } from "jest-mock";
-
-import "../../../olm-loader";
-import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
-import { logger } from "../../../../src/logger";
-import { OlmDevice } from "../../../../src/crypto/OlmDevice";
-import * as olmlib from "../../../../src/crypto/olmlib";
-import { DeviceInfo } from "../../../../src/crypto/deviceinfo";
-import { MatrixClient } from "../../../../src";
-
-function makeOlmDevice() {
-    const cryptoStore = new MemoryCryptoStore();
-    const olmDevice = new OlmDevice(cryptoStore);
-    return olmDevice;
-}
-
-async function setupSession(initiator: OlmDevice, opponent: OlmDevice) {
-    await opponent.generateOneTimeKeys(1);
-    const keys = await opponent.getOneTimeKeys();
-    const firstKey = Object.values(keys["curve25519"])[0];
-
-    const sid = await initiator.createOutboundSession(opponent.deviceCurve25519Key!, firstKey);
-    return sid;
-}
-
-function alwaysSucceed<T>(promise: Promise<T>): Promise<T | void> {
-    // swallow any exception thrown by a promise, so that
-    // Promise.all doesn't abort
-    return promise.catch(() => {});
-}
-
-describe("OlmDevice", function () {
-    if (!globalThis.Olm) {
-        logger.warn("Not running megolm unit tests: libolm not present");
-        return;
-    }
-
-    beforeAll(function () {
-        return globalThis.Olm.init();
-    });
-
-    let aliceOlmDevice: OlmDevice;
-    let bobOlmDevice: OlmDevice;
-
-    beforeEach(async function () {
-        aliceOlmDevice = makeOlmDevice();
-        bobOlmDevice = makeOlmDevice();
-        await aliceOlmDevice.init();
-        await bobOlmDevice.init();
-    });
-
-    describe("olm", function () {
-        it("can decrypt messages", async function () {
-            const sid = await setupSession(aliceOlmDevice, bobOlmDevice);
-
-            const ciphertext = (await aliceOlmDevice.encryptMessage(
-                bobOlmDevice.deviceCurve25519Key!,
-                sid,
-                "The olm or proteus is an aquatic salamander in the family Proteidae",
-            )) as any; // OlmDevice.encryptMessage has incorrect return type
-
-            const result = await bobOlmDevice.createInboundSession(
-                aliceOlmDevice.deviceCurve25519Key!,
-                ciphertext.type,
-                ciphertext.body,
-            );
-            expect(result.payload).toEqual("The olm or proteus is an aquatic salamander in the family Proteidae");
-        });
-
-        it("exports picked account and olm sessions", async function () {
-            const sessionId = await setupSession(aliceOlmDevice, bobOlmDevice);
-
-            const exported = await bobOlmDevice.export();
-            // At this moment only Alice (the “initiator” in setupSession) has a session
-            expect(exported.sessions).toEqual([]);
-
-            const MESSAGE = "The olm or proteus is an aquatic salamander" + " in the family Proteidae";
-            const ciphertext = (await aliceOlmDevice.encryptMessage(
-                bobOlmDevice.deviceCurve25519Key!,
-                sessionId,
-                MESSAGE,
-            )) as any; // OlmDevice.encryptMessage has incorrect return type
-
-            const bobRecreatedOlmDevice = makeOlmDevice();
-            bobRecreatedOlmDevice.init({ fromExportedDevice: exported });
-
-            const decrypted = await bobRecreatedOlmDevice.createInboundSession(
-                aliceOlmDevice.deviceCurve25519Key!,
-                ciphertext.type,
-                ciphertext.body,
-            );
-            expect(decrypted.payload).toEqual(MESSAGE);
-
-            const exportedAgain = await bobRecreatedOlmDevice.export();
-            // this time we expect Bob to have a session to export
-            expect(exportedAgain.sessions).toHaveLength(1);
-
-            const MESSAGE_2 = "In contrast to most amphibians," + " the olm is entirely aquatic";
-            const ciphertext2 = (await aliceOlmDevice.encryptMessage(
-                bobOlmDevice.deviceCurve25519Key!,
-                sessionId,
-                MESSAGE_2,
-            )) as any; // OlmDevice.encryptMessage has incorrect return type
-
-            const bobRecreatedAgainOlmDevice = makeOlmDevice();
-            bobRecreatedAgainOlmDevice.init({ fromExportedDevice: exportedAgain });
-
-            // Note: "decrypted_2" does not have the same structure as "decrypted"
-            const decrypted2 = await bobRecreatedAgainOlmDevice.decryptMessage(
-                aliceOlmDevice.deviceCurve25519Key!,
-                decrypted.session_id,
-                ciphertext2.type,
-                ciphertext2.body,
-            );
-            expect(decrypted2).toEqual(MESSAGE_2);
-        });
-
-        it("creates only one session at a time", async function () {
-            // if we call ensureOlmSessionsForDevices multiple times, it should
-            // only try to create one session at a time, even if the server is
-            // slow
-            let count = 0;
-            const baseApis = {
-                claimOneTimeKeys: () => {
-                    // simulate a very slow server (.5 seconds to respond)
-                    count++;
-                    return new Promise((resolve, reject) => {
-                        setTimeout(reject, 500);
-                    });
-                },
-            } as unknown as MockedObject<MatrixClient>;
-            const devicesByUser = new Map([
-                [
-                    "@bob:example.com",
-                    [
-                        DeviceInfo.fromStorage(
-                            {
-                                keys: {
-                                    "curve25519:ABCDEFG": "akey",
-                                },
-                            },
-                            "ABCDEFG",
-                        ),
-                    ],
-                ],
-            ]);
-
-            // start two tasks that try to ensure that there's an olm session
-            const promises = Promise.all([
-                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUser)),
-                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUser)),
-            ]);
-
-            await new Promise((resolve) => {
-                setTimeout(resolve, 200);
-            });
-
-            // after .2s, both tasks should have started, but one should be
-            // waiting on the other before trying to create a session, so
-            // claimOneTimeKeys should have only been called once
-            expect(count).toBe(1);
-
-            await promises;
-
-            // after waiting for both tasks to complete, the first task should
-            // have failed, so the second task should have tried to create a
-            // new session and will have called claimOneTimeKeys
-            expect(count).toBe(2);
-        });
-
-        it("avoids deadlocks when two tasks are ensuring the same devices", async function () {
-            // This test checks whether `ensureOlmSessionsForDevices` properly
-            // handles multiple tasks in flight ensuring some set of devices in
-            // common without deadlocks.
-
-            let claimRequestCount = 0;
-            const baseApis = {
-                claimOneTimeKeys: () => {
-                    // simulate a very slow server (.5 seconds to respond)
-                    claimRequestCount++;
-                    return new Promise((resolve, reject) => {
-                        setTimeout(reject, 500);
-                    });
-                },
-            } as unknown as MockedObject<MatrixClient>;
-
-            const deviceBobA = DeviceInfo.fromStorage(
-                {
-                    keys: {
-                        "curve25519:BOB-A": "akey",
-                    },
-                },
-                "BOB-A",
-            );
-            const deviceBobB = DeviceInfo.fromStorage(
-                {
-                    keys: {
-                        "curve25519:BOB-B": "bkey",
-                    },
-                },
-                "BOB-B",
-            );
-
-            // There's no required ordering of devices per user, so here we
-            // create two different orderings so that each task reserves a
-            // device the other task needs before continuing.
-            const devicesByUserAB = new Map([["@bob:example.com", [deviceBobA, deviceBobB]]]);
-            const devicesByUserBA = new Map([["@bob:example.com", [deviceBobB, deviceBobA]]]);
-
-            const task1 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUserAB));
-
-            // After a single tick through the first task, it should have
-            // claimed ownership of all devices to avoid deadlocking others.
-            expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);
-
-            const task2 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUserBA));
-
-            // The second task should not have changed the ownership count, as
-            // it's waiting on the first task.
-            expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);
-
-            // Track the tasks, but don't await them yet.
-            const promises = Promise.all([task1, task2]);
-
-            await new Promise((resolve) => {
-                setTimeout(resolve, 200);
-            });
-
-            // After .2s, the first task should have made an initial claim request.
-            expect(claimRequestCount).toBe(1);
-
-            await promises;
-
-            // After waiting for both tasks to complete, the first task should
-            // have failed, so the second task should have tried to create a
-            // new session and will have called claimOneTimeKeys
-            expect(claimRequestCount).toBe(2);
-        });
-    });
-});
@@ -1,791 +0,0 @@
-/*
-Copyright 2018 New Vector 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.
-*/
-
-import "../../olm-loader";
-import { logger } from "../../../src/logger";
-import * as olmlib from "../../../src/crypto/olmlib";
-import { MatrixClient } from "../../../src/client";
-import { MatrixEvent } from "../../../src/models/event";
-import * as algorithms from "../../../src/crypto/algorithms";
-import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
-import * as testUtils from "../../test-utils/test-utils";
-import { OlmDevice } from "../../../src/crypto/OlmDevice";
-import { Crypto } from "../../../src/crypto";
-import { resetCrossSigningKeys } from "./crypto-utils";
-import { BackupManager } from "../../../src/crypto/backup";
-import { StubStore } from "../../../src/store/stub";
-import { IndexedDBCryptoStore, MatrixScheduler } from "../../../src";
-import { CryptoStore } from "../../../src/crypto/store/base";
-import { MegolmDecryption as MegolmDecryptionClass } from "../../../src/crypto/algorithms/megolm";
-import { IKeyBackupInfo } from "../../../src/crypto/keybackup";
-
-const Olm = globalThis.Olm;
-
-const MegolmDecryption = algorithms.DECRYPTION_CLASSES.get("m.megolm.v1.aes-sha2")!;
-
-const ROOM_ID = "!ROOM:ID";
-
-const SESSION_ID = "o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc";
-const ENCRYPTED_EVENT = new MatrixEvent({
-    type: "m.room.encrypted",
-    room_id: "!ROOM:ID",
-    content: {
-        algorithm: "m.megolm.v1.aes-sha2",
-        sender_key: "SENDER_CURVE25519",
-        session_id: SESSION_ID,
-        ciphertext:
-            "AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N" +
-            "CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl" +
-            "mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs",
-    },
-    event_id: "$event1",
-    origin_server_ts: 1507753886000,
-});
-
-const CURVE25519_KEY_BACKUP_DATA = {
-    first_message_index: 0,
-    forwarded_count: 0,
-    is_verified: false,
-    session_data: {
-        ciphertext:
-            "2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw" +
-            "6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ" +
-            "Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9" +
-            "SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy" +
-            "Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF" +
-            "ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV" +
-            "4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv" +
-            "C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe" +
-            "Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf" +
-            "QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy" +
-            "iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg",
-        mac: "5lxYBHQU80M",
-        ephemeral: "/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14",
-    },
-};
-
-const AES256_KEY_BACKUP_DATA = {
-    first_message_index: 0,
-    forwarded_count: 0,
-    is_verified: false,
-    session_data: {
-        iv: "b3Jqqvm5S9QdmXrzssspLQ",
-        ciphertext:
-            "GOOASO3E9ThogkG0zMjEduGLM3u9jHZTkS7AvNNbNj3q1znwk4OlaVKXce" +
-            "7ynofiiYIiS865VlOqrKEEXv96XzRyUpgn68e3WsicwYl96EtjIEh/iY003PG2Qd" +
-            "EluT899Ax7PydpUHxEktbWckMppYomUR5q8x1KI1SsOQIiJaIGThmIMPANRCFiK0" +
-            "WQj+q+dnhzx4lt9AFqU5bKov8qKnw2qGYP7/+6RmJ0Kpvs8tG6lrcNDEHtFc2r0r" +
-            "KKubDypo0Vc8EWSwsAHdKa36ewRavpreOuE8Z9RLfY0QIR1ecXrMqW0CdGFr7H3P" +
-            "vcjF8sjwvQAavzxEKT1WMGizSMLeKWo2mgZ5cKnwV5HGUAw596JQvKs9laG2U89K" +
-            "YrT0sH30vi62HKzcBLcDkWkUSNYPz7UiZ1MM0L380UA+1ZOXSOmtBA9xxzzbc8Xd" +
-            "fRimVgklGdxrxjzuNLYhL2BvVH4oPWonD9j0bvRwE6XkimdbGQA8HB7UmXXjE8WA" +
-            "RgaDHkfzoA3g3aeQ",
-        mac: "uR988UYgGL99jrvLLPX3V1ows+UYbktTmMxPAo2kxnU",
-    },
-};
-
-const CURVE25519_BACKUP_INFO = {
-    algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-    version: "1",
-    auth_data: {
-        public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-    },
-};
-
-const AES256_BACKUP_INFO: IKeyBackupInfo = {
-    algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
-    version: "1",
-    auth_data: {} as IKeyBackupInfo["auth_data"],
-};
-
-const keys: Record<string, Uint8Array> = {};
-
-function getCrossSigningKey(type: string) {
-    return Promise.resolve(keys[type]);
-}
-
-function saveCrossSigningKeys(k: Record<string, Uint8Array>) {
-    Object.assign(keys, k);
-}
-
-function makeTestScheduler(): MatrixScheduler {
-    return (["getQueueForEvent", "queueEvent", "removeEventFromQueue", "setProcessFunction"] as const).reduce(
-        (r, k) => {
-            r[k] = jest.fn();
-            return r;
-        },
-        {} as MatrixScheduler,
-    );
-}
-
-function makeTestClient(cryptoStore: CryptoStore) {
-    const scheduler = makeTestScheduler();
-    const store = new StubStore();
-
-    const client = new MatrixClient({
-        baseUrl: "https://my.home.server",
-        idBaseUrl: "https://identity.server",
-        accessToken: "my.access.token",
-        fetchFn: jest.fn(), // NOP
-        store: store,
-        scheduler: scheduler,
-        userId: "@alice:bar",
-        deviceId: "device",
-        cryptoStore: cryptoStore,
-        cryptoCallbacks: { getCrossSigningKey, saveCrossSigningKeys },
-    });
-
-    // initialising the crypto library will trigger a key upload request, which we can stub out
-    client.uploadKeysRequest = jest.fn();
-    return client;
-}
-
-describe("MegolmBackup", function () {
-    if (!globalThis.Olm) {
-        logger.warn("Not running megolm backup unit tests: libolm not present");
-        return;
-    }
-
-    beforeAll(function () {
-        return Olm.init();
-    });
-
-    let olmDevice: OlmDevice;
-    let mockOlmLib: typeof olmlib;
-    let mockCrypto: Crypto;
-    let cryptoStore: CryptoStore;
-    let megolmDecryption: MegolmDecryptionClass;
-    beforeEach(async function () {
-        mockCrypto = testUtils.mock(Crypto, "Crypto");
-        // @ts-ignore making mock
-        mockCrypto.backupManager = testUtils.mock(BackupManager, "BackupManager");
-        mockCrypto.backupManager.backupInfo = CURVE25519_BACKUP_INFO;
-
-        cryptoStore = new MemoryCryptoStore();
-
-        olmDevice = new OlmDevice(cryptoStore);
-
-        // we stub out the olm encryption bits
-        mockOlmLib = {} as unknown as typeof olmlib;
-        mockOlmLib.ensureOlmSessionsForDevices = jest.fn();
-        mockOlmLib.encryptMessageForDevice = jest.fn().mockResolvedValue(undefined);
-    });
-
-    describe("backup", function () {
-        let mockBaseApis: MatrixClient;
-
-        beforeEach(function () {
-            mockBaseApis = {} as unknown as MatrixClient;
-
-            megolmDecryption = new MegolmDecryption({
-                userId: "@user:id",
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: mockBaseApis,
-                roomId: ROOM_ID,
-            }) as MegolmDecryptionClass;
-
-            // @ts-ignore private field access
-            megolmDecryption.olmlib = mockOlmLib;
-
-            // clobber the setTimeout function to run 100x faster.
-            // ideally we would use lolex, but we have no oportunity
-            // to tick the clock between the first try and the retry.
-            const realSetTimeout = globalThis.setTimeout;
-            jest.spyOn(globalThis, "setTimeout").mockImplementation(function (f, n) {
-                return realSetTimeout(f!, n! / 100);
-            });
-        });
-
-        afterEach(function () {
-            jest.spyOn(globalThis, "setTimeout").mockRestore();
-        });
-
-        test("fail if crypto not enabled", async () => {
-            const client = makeTestClient(cryptoStore);
-            const data = {
-                algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                version: "1",
-                auth_data: {
-                    public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-                },
-            };
-            await expect(client.restoreKeyBackupWithSecretStorage(data)).rejects.toThrow(
-                "End-to-end encryption disabled",
-            );
-        });
-
-        test("fail if given backup has no version", async () => {
-            const client = makeTestClient(cryptoStore);
-            await client.initLegacyCrypto();
-            const data = {
-                algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                auth_data: {
-                    public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-                },
-            };
-            const key = Uint8Array.from([1, 2, 3, 4, 5, 6, 7, 8]);
-            await client.getCrypto()!.storeSessionBackupPrivateKey(key, "1");
-            await expect(client.restoreKeyBackupWithCache(undefined, undefined, data)).rejects.toThrow(
-                "Backup version must be defined",
-            );
-        });
-
-        it("automatically calls the key back up", function () {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-
-            // construct a fake decrypted key event via the use of a mocked
-            // 'crypto' implementation.
-            const event = new MatrixEvent({
-                type: "m.room.encrypted",
-            });
-            event.getWireType = () => "m.room.encrypted";
-            event.getWireContent = () => {
-                return {
-                    algorithm: "m.olm.v1.curve25519-aes-sha2",
-                };
-            };
-            const decryptedData = {
-                clearEvent: {
-                    type: "m.room_key",
-                    content: {
-                        algorithm: "m.megolm.v1.aes-sha2",
-                        room_id: ROOM_ID,
-                        session_id: groupSession.session_id(),
-                        session_key: groupSession.session_key(),
-                    },
-                },
-                senderCurve25519Key: "SENDER_CURVE25519",
-                claimedEd25519Key: "SENDER_ED25519",
-            };
-
-            mockCrypto.decryptEvent = function () {
-                return Promise.resolve(decryptedData);
-            };
-            mockCrypto.cancelRoomKeyRequest = function () {};
-
-            // @ts-ignore readonly field write
-            mockCrypto.backupManager = {
-                backupGroupSession: jest.fn(),
-            };
-
-            return event
-                .attemptDecryption(mockCrypto)
-                .then(() => {
-                    return megolmDecryption.onRoomKeyEvent(event);
-                })
-                .then(() => {
-                    expect(mockCrypto.backupManager.backupGroupSession).toHaveBeenCalled();
-                });
-        });
-
-        it("sends backups to the server (Curve25519 version)", function () {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-            const ibGroupSession = new Olm.InboundGroupSession();
-            ibGroupSession.create(groupSession.session_key());
-
-            const client = makeTestClient(cryptoStore);
-
-            megolmDecryption = new MegolmDecryption({
-                userId: "@user:id",
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            }) as MegolmDecryptionClass;
-
-            // @ts-ignore private field access
-            megolmDecryption.olmlib = mockOlmLib;
-
-            return client
-                .initLegacyCrypto()
-                .then(() => {
-                    return cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {
-                        cryptoStore.addEndToEndInboundGroupSession(
-                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                            groupSession.session_id(),
-                            {
-                                forwardingCurve25519KeyChain: undefined!,
-                                keysClaimed: {
-                                    ed25519: "SENDER_ED25519",
-                                },
-                                room_id: ROOM_ID,
-                                session: ibGroupSession.pickle(olmDevice.pickleKey),
-                            },
-                            txn,
-                        );
-                    });
-                })
-                .then(async () => {
-                    await client.enableKeyBackup({
-                        algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                        version: "1",
-                        auth_data: {
-                            public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-                        },
-                    });
-                    let numCalls = 0;
-                    return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function (method, path, queryParams, data, opts): any {
-                            ++numCalls;
-                            expect(numCalls).toBeLessThanOrEqual(1);
-                            if (numCalls >= 2) {
-                                // exit out of retry loop if there's something wrong
-                                reject(new Error("authedRequest called too many timmes"));
-                                return Promise.resolve({});
-                            }
-                            expect(method).toBe("PUT");
-                            expect(path).toBe("/room_keys/keys");
-                            expect(queryParams?.version).toBe("1");
-                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
-                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
-                                groupSession.session_id(),
-                            );
-                            resolve();
-                            return Promise.resolve({});
-                        };
-                        client.crypto!.backupManager.backupGroupSession(
-                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                            groupSession.session_id(),
-                        );
-                    }).then(() => {
-                        expect(numCalls).toBe(1);
-                        client.stopClient();
-                    });
-                });
-        });
-
-        it("sends backups to the server (AES-256 version)", function () {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-            const ibGroupSession = new Olm.InboundGroupSession();
-            ibGroupSession.create(groupSession.session_key());
-
-            const client = makeTestClient(cryptoStore);
-
-            megolmDecryption = new MegolmDecryption({
-                userId: "@user:id",
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            }) as MegolmDecryptionClass;
-
-            // @ts-ignore private field access
-            megolmDecryption.olmlib = mockOlmLib;
-
-            return client
-                .initLegacyCrypto()
-                .then(() => {
-                    return client.crypto!.storeSessionBackupPrivateKey(new Uint8Array(32));
-                })
-                .then(() => {
-                    return cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {
-                        cryptoStore.addEndToEndInboundGroupSession(
-                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                            groupSession.session_id(),
-                            {
-                                forwardingCurve25519KeyChain: undefined!,
-                                keysClaimed: {
-                                    ed25519: "SENDER_ED25519",
-                                },
-                                room_id: ROOM_ID,
-                                session: ibGroupSession.pickle(olmDevice.pickleKey),
-                            },
-                            txn,
-                        );
-                    });
-                })
-                .then(async () => {
-                    await client.enableKeyBackup({
-                        algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
-                        version: "1",
-                        auth_data: {
-                            iv: "PsCAtR7gMc4xBd9YS3A9Ow",
-                            mac: "ZSDsTFEZK7QzlauCLMleUcX96GQZZM7UNtk4sripSqQ",
-                        },
-                    });
-                    let numCalls = 0;
-                    return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function (method, path, queryParams, data, opts): any {
-                            ++numCalls;
-                            expect(numCalls).toBeLessThanOrEqual(1);
-                            if (numCalls >= 2) {
-                                // exit out of retry loop if there's something wrong
-                                reject(new Error("authedRequest called too many timmes"));
-                                return Promise.resolve({});
-                            }
-                            expect(method).toBe("PUT");
-                            expect(path).toBe("/room_keys/keys");
-                            expect(queryParams?.version).toBe("1");
-                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
-                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
-                                groupSession.session_id(),
-                            );
-                            resolve();
-                            return Promise.resolve({});
-                        };
-                        client.crypto!.backupManager.backupGroupSession(
-                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                            groupSession.session_id(),
-                        );
-                    }).then(() => {
-                        expect(numCalls).toBe(1);
-                        client.stopClient();
-                    });
-                });
-        });
-
-        it("signs backups with the cross-signing master key", async function () {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-            const ibGroupSession = new Olm.InboundGroupSession();
-            ibGroupSession.create(groupSession.session_key());
-
-            const client = makeTestClient(cryptoStore);
-
-            megolmDecryption = new MegolmDecryption({
-                userId: "@user:id",
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            }) as MegolmDecryptionClass;
-
-            // @ts-ignore private field access
-            megolmDecryption.olmlib = mockOlmLib;
-
-            await client.initLegacyCrypto();
-            client.uploadDeviceSigningKeys = async function (e) {
-                return {};
-            };
-            client.uploadKeySignatures = async function (e) {
-                return { failures: {} };
-            };
-            await resetCrossSigningKeys(client);
-            let numCalls = 0;
-            await Promise.all([
-                new Promise<void>((resolve, reject) => {
-                    let backupInfo: Record<string, any> | BodyInit | undefined;
-                    client.http.authedRequest = function (method, path, queryParams, data, opts): any {
-                        ++numCalls;
-                        expect(numCalls).toBeLessThanOrEqual(2);
-                        /* eslint-disable jest/no-conditional-expect */
-                        if (numCalls === 1) {
-                            expect(method).toBe("POST");
-                            expect(path).toBe("/room_keys/version");
-                            try {
-                                // make sure auth_data is signed by the master key
-                                olmlib.pkVerify(
-                                    (data as Record<string, any>).auth_data,
-                                    client.getCrossSigningId()!,
-                                    "@alice:bar",
-                                );
-                            } catch (e) {
-                                reject(e);
-                                return Promise.resolve({});
-                            }
-                            backupInfo = data;
-                            return Promise.resolve({});
-                        } else if (numCalls === 2) {
-                            expect(method).toBe("GET");
-                            expect(path).toBe("/room_keys/version");
-                            resolve();
-                            return Promise.resolve(backupInfo);
-                        } else {
-                            // exit out of retry loop if there's something wrong
-                            reject(new Error("authedRequest called too many times"));
-                            return Promise.resolve({});
-                        }
-                        /* eslint-enable jest/no-conditional-expect */
-                    };
-                }),
-                client.createKeyBackupVersion({
-                    algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                    auth_data: {
-                        public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-                    },
-                }),
-            ]);
-            expect(numCalls).toBe(2);
-            client.stopClient();
-        });
-
-        it("retries when a backup fails", async function () {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-            const ibGroupSession = new Olm.InboundGroupSession();
-            ibGroupSession.create(groupSession.session_key());
-
-            const scheduler = makeTestScheduler();
-            const store = new StubStore();
-            const client = new MatrixClient({
-                baseUrl: "https://my.home.server",
-                idBaseUrl: "https://identity.server",
-                accessToken: "my.access.token",
-                fetchFn: jest.fn(), // NOP
-                store: store,
-                scheduler: scheduler,
-                userId: "@alice:bar",
-                deviceId: "device",
-                cryptoStore: cryptoStore,
-            });
-            // initialising the crypto library will trigger a key upload request, which we can stub out
-            client.uploadKeysRequest = jest.fn();
-
-            megolmDecryption = new MegolmDecryption({
-                userId: "@user:id",
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            }) as MegolmDecryptionClass;
-
-            // @ts-ignore private field access
-            megolmDecryption.olmlib = mockOlmLib;
-
-            await client.initLegacyCrypto();
-            await cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {
-                cryptoStore.addEndToEndInboundGroupSession(
-                    "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                    groupSession.session_id(),
-                    {
-                        forwardingCurve25519KeyChain: undefined!,
-                        keysClaimed: {
-                            ed25519: "SENDER_ED25519",
-                        },
-                        room_id: ROOM_ID,
-                        session: ibGroupSession.pickle(olmDevice.pickleKey),
-                    },
-                    txn,
-                );
-            });
-
-            await client.enableKeyBackup({
-                algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                version: "1",
-                auth_data: {
-                    public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-                },
-            });
-            let numCalls = 0;
-
-            await new Promise<void>((resolve, reject) => {
-                client.http.authedRequest = function (method, path, queryParams, data, opts): any {
-                    ++numCalls;
-                    expect(numCalls).toBeLessThanOrEqual(2);
-                    if (numCalls >= 3) {
-                        // exit out of retry loop if there's something wrong
-                        reject(new Error("authedRequest called too many timmes"));
-                        return Promise.resolve({});
-                    }
-                    expect(method).toBe("PUT");
-                    expect(path).toBe("/room_keys/keys");
-                    expect(queryParams?.version).toBe("1");
-                    expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
-                    expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
-                        groupSession.session_id(),
-                    );
-                    if (numCalls > 1) {
-                        resolve();
-                        return Promise.resolve({});
-                    } else {
-                        return Promise.reject(new Error("this is an expected failure"));
-                    }
-                };
-                return client.crypto!.backupManager.backupGroupSession(
-                    "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                    groupSession.session_id(),
-                );
-            });
-            expect(numCalls).toBe(2);
-            client.stopClient();
-        });
-    });
-
-    describe("restore", function () {
-        let client: MatrixClient;
-
-        beforeEach(function () {
-            client = makeTestClient(cryptoStore);
-
-            megolmDecryption = new MegolmDecryption({
-                userId: "@user:id",
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            }) as MegolmDecryptionClass;
-
-            // @ts-ignore private field access
-            megolmDecryption.olmlib = mockOlmLib;
-
-            return client.initLegacyCrypto();
-        });
-
-        afterEach(function () {
-            client.stopClient();
-        });
-
-        it("can restore from backup (Curve25519 version)", function () {
-            client.http.authedRequest = function () {
-                return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
-            };
-            return client
-                .restoreKeyBackupWithRecoveryKey(
-                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                    ROOM_ID,
-                    SESSION_ID,
-                    CURVE25519_BACKUP_INFO,
-                )
-                .then(() => {
-                    return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-                })
-                .then((res) => {
-                    expect(res.clearEvent.content).toEqual("testytest");
-                    expect(res.untrusted).toBeTruthy(); // keys from Curve25519 backup are untrusted
-                });
-        });
-
-        it("can restore from backup (AES-256 version)", function () {
-            client.http.authedRequest = function () {
-                return Promise.resolve<any>(AES256_KEY_BACKUP_DATA);
-            };
-            return client
-                .restoreKeyBackupWithRecoveryKey(
-                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                    ROOM_ID,
-                    SESSION_ID,
-                    AES256_BACKUP_INFO,
-                )
-                .then(() => {
-                    return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-                })
-                .then((res) => {
-                    expect(res.clearEvent.content).toEqual("testytest");
-                    expect(res.untrusted).toBeFalsy(); // keys from AES backup are trusted
-                });
-        });
-
-        it("can restore backup by room (Curve25519 version)", function () {
-            client.http.authedRequest = function () {
-                return Promise.resolve<any>({
-                    rooms: {
-                        [ROOM_ID]: {
-                            sessions: {
-                                [SESSION_ID]: CURVE25519_KEY_BACKUP_DATA,
-                            },
-                        },
-                    },
-                });
-            };
-            return client
-                .restoreKeyBackupWithRecoveryKey(
-                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                    null!,
-                    null!,
-                    CURVE25519_BACKUP_INFO,
-                )
-                .then(() => {
-                    return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-                })
-                .then((res) => {
-                    expect(res.clearEvent.content).toEqual("testytest");
-                });
-        });
-
-        it("has working cache functions", async function () {
-            const key = Uint8Array.from([1, 2, 3, 4, 5, 6, 7, 8]);
-            await client.crypto!.storeSessionBackupPrivateKey(key);
-            const result = await client.crypto!.getSessionBackupPrivateKey();
-            expect(new Uint8Array(result!)).toEqual(key);
-        });
-
-        it("caches session backup keys as it encounters them", async function () {
-            const cachedNull = await client.crypto!.getSessionBackupPrivateKey();
-            expect(cachedNull).toBeNull();
-            client.http.authedRequest = function () {
-                return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
-            };
-            await new Promise<void>((resolve) => {
-                client.restoreKeyBackupWithRecoveryKey(
-                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                    ROOM_ID,
-                    SESSION_ID,
-                    CURVE25519_BACKUP_INFO,
-                    { cacheCompleteCallback: resolve },
-                );
-            });
-            const cachedKey = await client.crypto!.getSessionBackupPrivateKey();
-            expect(cachedKey).not.toBeNull();
-        });
-
-        it("fails if an known algorithm is used", async function () {
-            const BAD_BACKUP_INFO = Object.assign({}, CURVE25519_BACKUP_INFO, {
-                algorithm: "this.algorithm.does.not.exist",
-            });
-            client.http.authedRequest = function () {
-                return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
-            };
-
-            await expect(
-                client.restoreKeyBackupWithRecoveryKey(
-                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                    ROOM_ID,
-                    SESSION_ID,
-                    BAD_BACKUP_INFO,
-                ),
-            ).rejects.toThrow();
-        });
-    });
-
-    describe("flagAllGroupSessionsForBackup", () => {
-        it("should return number of sesions needing backup", async () => {
-            const scheduler = makeTestScheduler();
-            const store = new StubStore();
-            const client = new MatrixClient({
-                baseUrl: "https://my.home.server",
-                idBaseUrl: "https://identity.server",
-                accessToken: "my.access.token",
-                fetchFn: jest.fn(), // NOP
-                store,
-                scheduler,
-                userId: "@alice:bar",
-                deviceId: "device",
-                cryptoStore,
-            });
-            // initialising the crypto library will trigger a key upload request, which we can stub out
-            client.uploadKeysRequest = jest.fn();
-
-            await client.initLegacyCrypto();
-
-            cryptoStore.countSessionsNeedingBackup = jest.fn().mockReturnValue(6);
-            await expect(client.flagAllGroupSessionsForBackup()).resolves.toBe(6);
-            client.stopClient();
-        });
-    });
-
-    describe("getKeyBackupInfo", () => {
-        it("should return throw an `Not implemented`", async () => {
-            const client = makeTestClient(cryptoStore);
-            await client.initLegacyCrypto();
-            await expect(client.getCrypto()?.getKeyBackupInfo()).rejects.toThrow("Not implemented");
-        });
-    });
-});
@@ -1,42 +0,0 @@
-import { IRecoveryKey } from "../../../src/crypto/api";
-import { CrossSigningLevel } from "../../../src/crypto/CrossSigning";
-import { IndexedDBCryptoStore } from "../../../src/crypto/store/indexeddb-crypto-store";
-import { MatrixClient } from "../../../src";
-import { CryptoEvent } from "../../../src/crypto";
-
-// needs to be phased out and replaced with bootstrapSecretStorage,
-// but that is doing too much extra stuff for it to be an easy transition.
-export async function resetCrossSigningKeys(
-    client: MatrixClient,
-    { level }: { level?: CrossSigningLevel } = {},
-): Promise<void> {
-    const crypto = client.crypto!;
-
-    const oldKeys = Object.assign({}, crypto.crossSigningInfo.keys);
-    try {
-        await crypto.crossSigningInfo.resetKeys(level);
-        await crypto.signObject(crypto.crossSigningInfo.keys.master);
-        // write a copy locally so we know these are trusted keys
-        await crypto.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
-            crypto.cryptoStore.storeCrossSigningKeys(txn, crypto.crossSigningInfo.keys);
-        });
-    } catch (e) {
-        // If anything failed here, revert the keys so we know to try again from the start
-        // next time.
-        crypto.crossSigningInfo.keys = oldKeys;
-        throw e;
-    }
-    crypto.emit(CryptoEvent.KeysChanged, {});
-    // @ts-ignore
-    await crypto.afterCrossSigningLocalKeyChange();
-}
-
-export async function createSecretStorageKey(): Promise<IRecoveryKey> {
-    const decryption = new globalThis.Olm.PkDecryption();
-    decryption.generate_key();
-    const storagePrivateKey = decryption.get_private_key();
-    decryption.free();
-    return {
-        privateKey: storagePrivateKey,
-    };
-}
@@ -1,138 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import "../../olm-loader";
-import { TestClient } from "../../TestClient";
-import { logger } from "../../../src/logger";
-import { DEHYDRATION_ALGORITHM } from "../../../src/crypto/dehydration";
-
-const Olm = globalThis.Olm;
-
-describe("Dehydration", () => {
-    if (!globalThis.Olm) {
-        logger.warn("Not running dehydration unit tests: libolm not present");
-        return;
-    }
-
-    beforeAll(function () {
-        return globalThis.Olm.init();
-    });
-
-    it("should rehydrate a dehydrated device", async () => {
-        const key = new Uint8Array([1, 2, 3]);
-        const alice = new TestClient("@alice:example.com", "Osborne2", undefined, undefined, {
-            cryptoCallbacks: {
-                getDehydrationKey: async (t) => key,
-            },
-        });
-
-        const dehydratedDevice = new Olm.Account();
-        dehydratedDevice.create();
-
-        alice.httpBackend.when("GET", "/dehydrated_device").respond(200, {
-            device_id: "ABCDEFG",
-            device_data: {
-                algorithm: DEHYDRATION_ALGORITHM,
-                account: dehydratedDevice.pickle(new Uint8Array(key)),
-            },
-        });
-        alice.httpBackend.when("POST", "/dehydrated_device/claim").respond(200, {
-            success: true,
-        });
-
-        expect((await Promise.all([alice.client.rehydrateDevice(), alice.httpBackend.flushAllExpected()]))[0]).toEqual(
-            "ABCDEFG",
-        );
-
-        expect(alice.client.getDeviceId()).toEqual("ABCDEFG");
-    });
-
-    it("should dehydrate a device", async () => {
-        const key = new Uint8Array([1, 2, 3]);
-        const alice = new TestClient("@alice:example.com", "Osborne2", undefined, undefined, {
-            cryptoCallbacks: {
-                getDehydrationKey: async (t) => key,
-            },
-        });
-
-        await alice.client.initLegacyCrypto();
-
-        alice.httpBackend.when("GET", "/room_keys/version").respond(404, {
-            errcode: "M_NOT_FOUND",
-        });
-
-        let pickledAccount = "";
-
-        alice.httpBackend
-            .when("PUT", "/dehydrated_device")
-            .check((req) => {
-                expect(req.data.device_data).toMatchObject({
-                    algorithm: DEHYDRATION_ALGORITHM,
-                    account: expect.any(String),
-                });
-                pickledAccount = req.data.device_data.account;
-            })
-            .respond(200, {
-                device_id: "ABCDEFG",
-            });
-        alice.httpBackend
-            .when("POST", "/keys/upload/ABCDEFG")
-            .check((req) => {
-                expect(req.data).toMatchObject({
-                    "device_keys": expect.objectContaining({
-                        algorithms: expect.any(Array),
-                        device_id: "ABCDEFG",
-                        user_id: "@alice:example.com",
-                        keys: expect.objectContaining({
-                            "ed25519:ABCDEFG": expect.any(String),
-                            "curve25519:ABCDEFG": expect.any(String),
-                        }),
-                        signatures: expect.objectContaining({
-                            "@alice:example.com": expect.objectContaining({
-                                "ed25519:ABCDEFG": expect.any(String),
-                            }),
-                        }),
-                    }),
-                    "one_time_keys": expect.any(Object),
-                    "org.matrix.msc2732.fallback_keys": expect.any(Object),
-                });
-            })
-            .respond(200, {});
-
-        try {
-            const deviceId = (
-                await Promise.all([
-                    alice.client.createDehydratedDevice(new Uint8Array(key), {}),
-                    alice.httpBackend.flushAllExpected(),
-                ])
-            )[0];
-
-            expect(deviceId).toEqual("ABCDEFG");
-            expect(deviceId).not.toEqual("");
-
-            // try to rehydrate the dehydrated device
-            const rehydrated = new Olm.Account();
-            try {
-                rehydrated.unpickle(new Uint8Array(key), pickledAccount);
-            } finally {
-                rehydrated.free();
-            }
-        } finally {
-            alice.client?.crypto?.dehydrationManager?.stop();
-            alice.client?.crypto?.deviceList.stop();
-        }
-    });
-});
@@ -1,58 +0,0 @@
-/*
-Copyright 2023 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 { DeviceInfo } from "../../../src/crypto/deviceinfo";
-import { DeviceVerification } from "../../../src";
-import { deviceInfoToDevice } from "../../../src/crypto/device-converter";
-
-describe("device-converter", () => {
-    const userId = "@alice:example.com";
-    const deviceId = "xcvf";
-
-    // All parameters for DeviceInfo initialization
-    const keys = {
-        [`ed25519:${deviceId}`]: "key1",
-        [`curve25519:${deviceId}`]: "key2",
-    };
-    const algorithms = ["algo1", "algo2"];
-    const verified = DeviceVerification.Verified;
-    const signatures = { [userId]: { [deviceId]: "sign1" } };
-    const displayName = "display name";
-    const unsigned = {
-        device_display_name: displayName,
-    };
-
-    describe("deviceInfoToDevice", () => {
-        it("should convert a DeviceInfo to a Device", () => {
-            const deviceInfo = DeviceInfo.fromStorage({ keys, algorithms, verified, signatures, unsigned }, deviceId);
-            const device = deviceInfoToDevice(deviceInfo, userId);
-
-            expect(device.deviceId).toBe(deviceId);
-            expect(device.userId).toBe(userId);
-            expect(device.verified).toBe(verified);
-            expect(device.getIdentityKey()).toBe(keys[`curve25519:${deviceId}`]);
-            expect(device.getFingerprint()).toBe(keys[`ed25519:${deviceId}`]);
-            expect(device.displayName).toBe(displayName);
-        });
-
-        it("should add empty signatures", () => {
-            const deviceInfo = DeviceInfo.fromStorage({ keys, algorithms, verified }, deviceId);
-            const device = deviceInfoToDevice(deviceInfo, userId);
-
-            expect(device.signatures.size).toBe(0);
-        });
-    });
-});
@@ -1,91 +0,0 @@
-/*
-Copyright 2020 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 { CryptoStore } from "../../../src/crypto/store/base";
-import { IndexedDBCryptoStore } from "../../../src/crypto/store/indexeddb-crypto-store";
-import { LocalStorageCryptoStore } from "../../../src/crypto/store/localStorage-crypto-store";
-import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
-import { RoomKeyRequestState } from "../../../src/crypto/OutgoingRoomKeyRequestManager";
-
-import "fake-indexeddb/auto";
-import "jest-localstorage-mock";
-
-const requests = [
-    {
-        requestId: "A",
-        requestBody: { session_id: "A", room_id: "A", sender_key: "A", algorithm: "m.megolm.v1.aes-sha2" },
-        state: RoomKeyRequestState.Sent,
-        recipients: [
-            { userId: "@alice:example.com", deviceId: "*" },
-            { userId: "@becca:example.com", deviceId: "foobarbaz" },
-        ],
-    },
-    {
-        requestId: "B",
-        requestBody: { session_id: "B", room_id: "B", sender_key: "B", algorithm: "m.megolm.v1.aes-sha2" },
-        state: RoomKeyRequestState.Sent,
-        recipients: [
-            { userId: "@alice:example.com", deviceId: "*" },
-            { userId: "@carrie:example.com", deviceId: "barbazquux" },
-        ],
-    },
-    {
-        requestId: "C",
-        requestBody: { session_id: "C", room_id: "C", sender_key: "B", algorithm: "m.megolm.v1.aes-sha2" },
-        state: RoomKeyRequestState.Unsent,
-        recipients: [{ userId: "@becca:example.com", deviceId: "foobarbaz" }],
-    },
-];
-
-describe.each([
-    ["IndexedDBCryptoStore", () => new IndexedDBCryptoStore(globalThis.indexedDB, "tests")],
-    ["LocalStorageCryptoStore", () => new LocalStorageCryptoStore(localStorage)],
-    ["MemoryCryptoStore", () => new MemoryCryptoStore()],
-])("Outgoing room key requests [%s]", function (name, dbFactory) {
-    let store: CryptoStore;
-
-    beforeAll(async () => {
-        store = dbFactory();
-        await store.startup();
-        await Promise.all(requests.map((request) => store.getOrAddOutgoingRoomKeyRequest(request)));
-    });
-
-    it("getAllOutgoingRoomKeyRequestsByState retrieves all entries in a given state", async () => {
-        const r = await store.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);
-        expect(r).toHaveLength(2);
-        requests
-            .filter((e) => e.state === RoomKeyRequestState.Sent)
-            .forEach((e) => {
-                expect(r).toContainEqual(e);
-            });
-    });
-
-    it("getOutgoingRoomKeyRequestsByTarget retrieves all entries with a given target", async () => {
-        const r = await store.getOutgoingRoomKeyRequestsByTarget("@becca:example.com", "foobarbaz", [
-            RoomKeyRequestState.Sent,
-        ]);
-        expect(r).toHaveLength(1);
-        expect(r[0]).toEqual(requests[0]);
-    });
-
-    test("getOutgoingRoomKeyRequestByState retrieves any entry in a given state", async () => {
-        const r = await store.getOutgoingRoomKeyRequestByState([RoomKeyRequestState.Sent]);
-        expect(r).not.toBeNull();
-        expect(r).not.toBeUndefined();
-        expect(r!.state).toEqual(RoomKeyRequestState.Sent);
-        expect(requests).toContainEqual(r);
-    });
-});
@@ -1,697 +0,0 @@
-/*
-Copyright 2019, 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import "../../olm-loader";
-import * as olmlib from "../../../src/crypto/olmlib";
-import { IObject } from "../../../src/crypto/olmlib";
-import { MatrixEvent } from "../../../src/models/event";
-import { TestClient } from "../../TestClient";
-import { makeTestClients } from "./verification/util";
-import encryptAESSecretStorageItem from "../../../src/utils/encryptAESSecretStorageItem.ts";
-import { createSecretStorageKey, resetCrossSigningKeys } from "./crypto-utils";
-import { logger } from "../../../src/logger";
-import { ClientEvent, ICreateClientOpts, MatrixClient } from "../../../src/client";
-import { DeviceInfo } from "../../../src/crypto/deviceinfo";
-import { ISignatures } from "../../../src/@types/signed";
-import { ICurve25519AuthData } from "../../../src/crypto/keybackup";
-import { SecretStorageKeyDescription, SECRET_STORAGE_ALGORITHM_V1_AES } from "../../../src/secret-storage";
-import { decodeBase64 } from "../../../src/base64";
-import { CrossSigningKeyInfo } from "../../../src/crypto-api";
-import { SecretInfo } from "../../../src/secret-storage.ts";
-
-async function makeTestClient(
-    userInfo: { userId: string; deviceId: string },
-    options: Partial<ICreateClientOpts> = {},
-) {
-    const client = new TestClient(userInfo.userId, userInfo.deviceId, undefined, undefined, options).client;
-
-    // Make it seem as if we've synced and thus the store can be trusted to
-    // contain valid account data.
-    client.isInitialSyncComplete = function () {
-        return true;
-    };
-
-    await client.initLegacyCrypto();
-
-    // No need to download keys for these tests
-    jest.spyOn(client.crypto!, "downloadKeys").mockResolvedValue(new Map());
-
-    return client;
-}
-
-// Wrapper around pkSign to return a signed object. pkSign returns the
-// signature, rather than the signed object.
-function sign<T extends IObject | ICurve25519AuthData>(
-    obj: T,
-    key: Uint8Array,
-    userId: string,
-): T & {
-    signatures: ISignatures;
-    unsigned?: object;
-} {
-    olmlib.pkSign(obj, key, userId, "");
-    return obj as T & {
-        signatures: ISignatures;
-        unsigned?: object;
-    };
-}
-
-declare module "../../../src/@types/event" {
-    interface SecretStorageAccountDataEvents {
-        foo: SecretInfo;
-    }
-}
-
-describe("Secrets", function () {
-    if (!globalThis.Olm) {
-        logger.warn("Not running megolm backup unit tests: libolm not present");
-        return;
-    }
-
-    beforeAll(function () {
-        return globalThis.Olm.init();
-    });
-
-    it("should store and retrieve a secret", async function () {
-        const key = new Uint8Array(16);
-        for (let i = 0; i < 16; i++) key[i] = i;
-
-        const signing = new globalThis.Olm.PkSigning();
-        const signingKey = signing.generate_seed();
-        const signingPubKey = signing.init_with_seed(signingKey);
-
-        const signingkeyInfo = {
-            user_id: "@alice:example.com",
-            usage: ["master"],
-            keys: {
-                ["ed25519:" + signingPubKey]: signingPubKey,
-            },
-        };
-
-        const getKey = jest.fn().mockImplementation(async (e) => {
-            expect(Object.keys(e.keys)).toEqual(["abc"]);
-            return ["abc", key];
-        });
-
-        const alice = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-            {
-                cryptoCallbacks: {
-                    getCrossSigningKey: async (t) => signingKey,
-                    getSecretStorageKey: getKey,
-                },
-            },
-        );
-        alice.crypto!.crossSigningInfo.setKeys({
-            master: signingkeyInfo,
-        });
-
-        const secretStorage = alice.crypto!.secretStorage;
-
-        jest.spyOn(alice, "setAccountData").mockImplementation(async function (eventType, contents) {
-            alice.store.storeAccountDataEvents([
-                new MatrixEvent({
-                    type: eventType,
-                    content: contents,
-                }),
-            ]);
-            return {};
-        });
-
-        const keyAccountData = {
-            algorithm: SECRET_STORAGE_ALGORITHM_V1_AES,
-        };
-        await alice.crypto!.crossSigningInfo.signObject(keyAccountData, "master");
-
-        alice.store.storeAccountDataEvents([
-            new MatrixEvent({
-                type: "m.secret_storage.key.abc",
-                content: keyAccountData,
-            }),
-        ]);
-
-        expect(await secretStorage.isStored("foo")).toBeFalsy();
-
-        await secretStorage.store("foo", "bar", ["abc"]);
-
-        expect(await secretStorage.isStored("foo")).toBeTruthy();
-        expect(await secretStorage.get("foo")).toBe("bar");
-
-        expect(getKey).toHaveBeenCalled();
-        alice.stopClient();
-    });
-
-    it("should throw if given a key that doesn't exist", async function () {
-        const alice = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
-
-        await expect(alice.storeSecret("foo", "bar", ["this secret does not exist"])).rejects.toBeTruthy();
-        alice.stopClient();
-    });
-
-    it("should refuse to encrypt with zero keys", async function () {
-        const alice = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
-
-        await expect(alice.storeSecret("foo", "bar", [])).rejects.toBeTruthy();
-        alice.stopClient();
-    });
-
-    it("should encrypt with default key if keys is null", async function () {
-        const key = new Uint8Array(16);
-        for (let i = 0; i < 16; i++) key[i] = i;
-        const getKey = jest.fn().mockImplementation(async (e) => {
-            expect(Object.keys(e.keys)).toEqual([newKeyId]);
-            return [newKeyId, key];
-        });
-
-        let keys: Record<string, Uint8Array> = {};
-        const alice = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-            {
-                cryptoCallbacks: {
-                    getCrossSigningKey: (t) => Promise.resolve(keys[t]),
-                    saveCrossSigningKeys: (k) => (keys = k),
-                    getSecretStorageKey: getKey,
-                },
-            },
-        );
-        alice.setAccountData = async function (eventType, contents) {
-            alice.store.storeAccountDataEvents([
-                new MatrixEvent({
-                    type: eventType,
-                    content: contents,
-                }),
-            ]);
-            return {};
-        };
-        resetCrossSigningKeys(alice);
-
-        const { keyId: newKeyId } = await alice.addSecretStorageKey(SECRET_STORAGE_ALGORITHM_V1_AES, { key });
-        // we don't await on this because it waits for the event to come down the sync
-        // which won't happen in the test setup
-        alice.setDefaultSecretStorageKeyId(newKeyId);
-        await alice.storeSecret("foo", "bar");
-
-        const accountData = alice.getAccountData("foo");
-        expect(accountData!.getContent().encrypted).toBeTruthy();
-        alice.stopClient();
-    });
-
-    it("should refuse to encrypt if no keys given and no default key", async function () {
-        const alice = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
-
-        await expect(alice.storeSecret("foo", "bar")).rejects.toBeTruthy();
-        alice.stopClient();
-    });
-
-    it("should request secrets from other clients", async function () {
-        const [[osborne2, vax], clearTestClientTimeouts] = await makeTestClients(
-            [
-                { userId: "@alice:example.com", deviceId: "Osborne2" },
-                { userId: "@alice:example.com", deviceId: "VAX" },
-            ],
-            {
-                cryptoCallbacks: {
-                    onSecretRequested: (userId, deviceId, requestId, secretName, deviceTrust) => {
-                        expect(secretName).toBe("foo");
-                        return Promise.resolve("bar");
-                    },
-                },
-            },
-        );
-
-        const vaxDevice = vax.client.crypto!.olmDevice;
-        const osborne2Device = osborne2.client.crypto!.olmDevice;
-        const secretStorage = osborne2.client.crypto!.secretStorage;
-
-        osborne2.client.crypto!.deviceList.storeDevicesForUser("@alice:example.com", {
-            VAX: {
-                known: false,
-                algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                keys: {
-                    "ed25519:VAX": vaxDevice.deviceEd25519Key!,
-                    "curve25519:VAX": vaxDevice.deviceCurve25519Key!,
-                },
-                verified: DeviceInfo.DeviceVerification.VERIFIED,
-            },
-        });
-        vax.client.crypto!.deviceList.storeDevicesForUser("@alice:example.com", {
-            Osborne2: {
-                algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                verified: 0,
-                known: false,
-                keys: {
-                    "ed25519:Osborne2": osborne2Device.deviceEd25519Key!,
-                    "curve25519:Osborne2": osborne2Device.deviceCurve25519Key!,
-                },
-            },
-        });
-
-        await osborne2Device.generateOneTimeKeys(1);
-        const otks = (await osborne2Device.getOneTimeKeys()).curve25519;
-        await osborne2Device.markKeysAsPublished();
-
-        await vax.client.crypto!.olmDevice.createOutboundSession(
-            osborne2Device.deviceCurve25519Key!,
-            Object.values(otks)[0],
-        );
-
-        osborne2.client.crypto!.deviceList.downloadKeys = () => Promise.resolve(new Map());
-        osborne2.client.crypto!.deviceList.getUserByIdentityKey = () => "@alice:example.com";
-
-        const request = await secretStorage.request("foo", ["VAX"]);
-        await request.promise; // return value not used
-
-        osborne2.stop();
-        vax.stop();
-        clearTestClientTimeouts();
-    });
-
-    describe("bootstrap", function () {
-        // keys used in some of the tests
-        const XSK = new Uint8Array(decodeBase64("3lo2YdJugHjfE+Or7KJ47NuKbhE7AAGLgQ/dc19913Q="));
-        const XSPubKey = "DRb8pFVJyEJ9OWvXeUoM0jq/C2Wt+NxzBZVuk2nRb+0";
-        const USK = new Uint8Array(decodeBase64("lKWi3hJGUie5xxHgySoz8PHFnZv6wvNaud/p2shN9VU="));
-        const USPubKey = "CUpoiTtHiyXpUmd+3ohb7JVxAlUaOG1NYs9Jlx8soQU";
-        const SSK = new Uint8Array(decodeBase64("1R6JVlXX99UcfUZzKuCDGQgJTw8ur1/ofgPD8pp+96M="));
-        const SSPubKey = "0DfNsRDzEvkCLA0gD3m7VAGJ5VClhjEsewI35xq873Q";
-        const SSSSKey = new Uint8Array(decodeBase64("XrmITOOdBhw6yY5Bh7trb/bgp1FRdIGyCUxxMP873R0="));
-
-        it("bootstraps when no storage or cross-signing keys locally", async function () {
-            const key = new Uint8Array(16);
-            for (let i = 0; i < 16; i++) key[i] = i;
-            const getKey = jest.fn().mockImplementation(async (e) => {
-                return [Object.keys(e.keys)[0], key];
-            });
-
-            const bob = await makeTestClient(
-                {
-                    userId: "@bob:example.com",
-                    deviceId: "bob1",
-                },
-                {
-                    cryptoCallbacks: {
-                        getSecretStorageKey: getKey,
-                    },
-                },
-            );
-            bob.uploadDeviceSigningKeys = async () => ({});
-            bob.uploadKeySignatures = jest.fn().mockResolvedValue(undefined);
-            bob.setAccountData = async function (eventType, contents) {
-                const event = new MatrixEvent({
-                    type: eventType,
-                    content: contents,
-                });
-                this.store.storeAccountDataEvents([event]);
-                this.emit(ClientEvent.AccountData, event);
-                return {};
-            };
-            bob.getKeyBackupVersion = jest.fn().mockResolvedValue(null);
-
-            await bob.bootstrapCrossSigning({
-                authUploadDeviceSigningKeys: async (func) => {
-                    await func({});
-                },
-            });
-            await bob.bootstrapSecretStorage({
-                createSecretStorageKey,
-            });
-
-            const crossSigning = bob.crypto!.crossSigningInfo;
-            const secretStorage = bob.crypto!.secretStorage;
-
-            expect(crossSigning.getId()).toBeTruthy();
-            expect(await crossSigning.isStoredInSecretStorage(secretStorage)).toBeTruthy();
-            expect(await secretStorage.hasKey()).toBeTruthy();
-            bob.stopClient();
-        });
-
-        it("bootstraps when cross-signing keys in secret storage", async function () {
-            const decryption = new globalThis.Olm.PkDecryption();
-            const storagePrivateKey = decryption.get_private_key();
-
-            const bob: MatrixClient = await makeTestClient(
-                {
-                    userId: "@bob:example.com",
-                    deviceId: "bob1",
-                },
-                {
-                    cryptoCallbacks: {
-                        getSecretStorageKey: async (request) => {
-                            const defaultKeyId = await bob.getDefaultSecretStorageKeyId();
-                            expect(Object.keys(request.keys)).toEqual([defaultKeyId]);
-                            return [defaultKeyId!, storagePrivateKey];
-                        },
-                    },
-                },
-            );
-
-            bob.uploadDeviceSigningKeys = async () => ({});
-            bob.uploadKeySignatures = async () => ({ failures: {} });
-            bob.setAccountData = async function (eventType, contents) {
-                const event = new MatrixEvent({
-                    type: eventType,
-                    content: contents,
-                });
-                this.store.storeAccountDataEvents([event]);
-                this.emit(ClientEvent.AccountData, event);
-                return {};
-            };
-            bob.crypto!.backupManager.checkKeyBackup = async () => null;
-
-            const crossSigning = bob.crypto!.crossSigningInfo;
-            const secretStorage = bob.crypto!.secretStorage;
-
-            // Set up cross-signing keys from scratch with specific storage key
-            await bob.bootstrapCrossSigning({
-                authUploadDeviceSigningKeys: async (func) => {
-                    await func({});
-                },
-            });
-            await bob.bootstrapSecretStorage({
-                createSecretStorageKey: async () => ({
-                    privateKey: storagePrivateKey,
-                }),
-            });
-
-            // Clear local cross-signing keys and read from secret storage
-            bob.crypto!.deviceList.storeCrossSigningForUser("@bob:example.com", crossSigning.toStorage());
-            crossSigning.keys = {};
-            await bob.bootstrapCrossSigning({
-                authUploadDeviceSigningKeys: async (func) => {
-                    await func({});
-                },
-            });
-
-            expect(crossSigning.getId()).toBeTruthy();
-            expect(await crossSigning.isStoredInSecretStorage(secretStorage)).toBeTruthy();
-            expect(await secretStorage.hasKey()).toBeTruthy();
-            bob.stopClient();
-        });
-
-        it("adds passphrase checking if it's lacking", async function () {
-            let crossSigningKeys: Record<string, Uint8Array> = {
-                master: XSK,
-                user_signing: USK,
-                self_signing: SSK,
-            };
-            const secretStorageKeys: Record<string, Uint8Array> = {
-                key_id: SSSSKey,
-            };
-            const alice = await makeTestClient(
-                { userId: "@alice:example.com", deviceId: "Osborne2" },
-                {
-                    cryptoCallbacks: {
-                        getCrossSigningKey: async (t) => crossSigningKeys[t],
-                        saveCrossSigningKeys: (k) => (crossSigningKeys = k),
-                        getSecretStorageKey: async ({ keys }, name) => {
-                            for (const keyId of Object.keys(keys)) {
-                                if (secretStorageKeys[keyId]) {
-                                    return [keyId, secretStorageKeys[keyId]];
-                                }
-                            }
-                            return null;
-                        },
-                    },
-                },
-            );
-            alice.store.storeAccountDataEvents([
-                new MatrixEvent({
-                    type: "m.secret_storage.default_key",
-                    content: {
-                        key: "key_id",
-                    },
-                }),
-                new MatrixEvent({
-                    type: "m.secret_storage.key.key_id",
-                    content: {
-                        algorithm: "m.secret_storage.v1.aes-hmac-sha2",
-                        passphrase: {
-                            algorithm: "m.pbkdf2",
-                            iterations: 500000,
-                            salt: "GbkvwKHVMveo1zGVSb2GMMdCinG2npJK",
-                        },
-                    },
-                }),
-                // we never use these values, other than checking that they
-                // exist, so just use dummy values
-                new MatrixEvent({
-                    type: "m.cross_signing.master",
-                    content: {
-                        encrypted: {
-                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
-                        },
-                    },
-                }),
-                new MatrixEvent({
-                    type: "m.cross_signing.self_signing",
-                    content: {
-                        encrypted: {
-                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
-                        },
-                    },
-                }),
-                new MatrixEvent({
-                    type: "m.cross_signing.user_signing",
-                    content: {
-                        encrypted: {
-                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
-                        },
-                    },
-                }),
-            ]);
-            alice.crypto!.deviceList.storeCrossSigningForUser("@alice:example.com", {
-                firstUse: false,
-                crossSigningVerifiedBefore: false,
-                keys: {
-                    master: {
-                        user_id: "@alice:example.com",
-                        usage: ["master"],
-                        keys: {
-                            [`ed25519:${XSPubKey}`]: XSPubKey,
-                        },
-                    },
-                    self_signing: sign<CrossSigningKeyInfo>(
-                        {
-                            user_id: "@alice:example.com",
-                            usage: ["self_signing"],
-                            keys: {
-                                [`ed25519:${SSPubKey}`]: SSPubKey,
-                            },
-                        },
-                        XSK,
-                        "@alice:example.com",
-                    ),
-                    user_signing: sign<CrossSigningKeyInfo>(
-                        {
-                            user_id: "@alice:example.com",
-                            usage: ["user_signing"],
-                            keys: {
-                                [`ed25519:${USPubKey}`]: USPubKey,
-                            },
-                        },
-                        XSK,
-                        "@alice:example.com",
-                    ),
-                },
-            });
-            alice.getKeyBackupVersion = async () => {
-                return {
-                    version: "1",
-                    algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
-                    auth_data: sign(
-                        {
-                            public_key: "pxEXhg+4vdMf/kFwP4bVawFWdb0EmytL3eFJx++zQ0A",
-                        },
-                        XSK,
-                        "@alice:example.com",
-                    ),
-                };
-            };
-            alice.setAccountData = async function (name, data) {
-                const event = new MatrixEvent({
-                    type: name,
-                    content: data,
-                });
-                alice.store.storeAccountDataEvents([event]);
-                this.emit(ClientEvent.AccountData, event);
-                return {};
-            };
-
-            await alice.bootstrapSecretStorage({});
-
-            expect(alice.getAccountData("m.secret_storage.default_key")!.getContent()).toEqual({ key: "key_id" });
-            const keyInfo = alice
-                .getAccountData("m.secret_storage.key.key_id")!
-                .getContent<SecretStorageKeyDescription>();
-            expect(keyInfo.algorithm).toEqual("m.secret_storage.v1.aes-hmac-sha2");
-            expect(keyInfo.passphrase).toEqual({
-                algorithm: "m.pbkdf2",
-                iterations: 500000,
-                salt: "GbkvwKHVMveo1zGVSb2GMMdCinG2npJK",
-            });
-            expect(keyInfo).toHaveProperty("iv");
-            expect(keyInfo).toHaveProperty("mac");
-            expect(alice.checkSecretStorageKey(secretStorageKeys.key_id, keyInfo)).toBeTruthy();
-            alice.stopClient();
-        });
-        it("fixes backup keys in the wrong format", async function () {
-            let crossSigningKeys: Record<string, Uint8Array> = {
-                master: XSK,
-                user_signing: USK,
-                self_signing: SSK,
-            };
-            const secretStorageKeys: Record<string, Uint8Array> = {
-                key_id: SSSSKey,
-            };
-            const alice = await makeTestClient(
-                { userId: "@alice:example.com", deviceId: "Osborne2" },
-                {
-                    cryptoCallbacks: {
-                        getCrossSigningKey: async (t) => crossSigningKeys[t],
-                        saveCrossSigningKeys: (k) => (crossSigningKeys = k),
-                        getSecretStorageKey: async ({ keys }, name) => {
-                            for (const keyId of Object.keys(keys)) {
-                                if (secretStorageKeys[keyId]) {
-                                    return [keyId, secretStorageKeys[keyId]];
-                                }
-                            }
-                            return null;
-                        },
-                    },
-                },
-            );
-            alice.store.storeAccountDataEvents([
-                new MatrixEvent({
-                    type: "m.secret_storage.default_key",
-                    content: {
-                        key: "key_id",
-                    },
-                }),
-                new MatrixEvent({
-                    type: "m.secret_storage.key.key_id",
-                    content: {
-                        algorithm: "m.secret_storage.v1.aes-hmac-sha2",
-                        passphrase: {
-                            algorithm: "m.pbkdf2",
-                            iterations: 500000,
-                            salt: "GbkvwKHVMveo1zGVSb2GMMdCinG2npJK",
-                        },
-                    },
-                }),
-                new MatrixEvent({
-                    type: "m.cross_signing.master",
-                    content: {
-                        encrypted: {
-                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
-                        },
-                    },
-                }),
-                new MatrixEvent({
-                    type: "m.cross_signing.self_signing",
-                    content: {
-                        encrypted: {
-                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
-                        },
-                    },
-                }),
-                new MatrixEvent({
-                    type: "m.cross_signing.user_signing",
-                    content: {
-                        encrypted: {
-                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
-                        },
-                    },
-                }),
-                new MatrixEvent({
-                    type: "m.megolm_backup.v1",
-                    content: {
-                        encrypted: {
-                            key_id: await encryptAESSecretStorageItem(
-                                "123,45,6,7,89,1,234,56,78,90,12,34,5,67,8,90",
-                                secretStorageKeys.key_id,
-                                "m.megolm_backup.v1",
-                            ),
-                        },
-                    },
-                }),
-            ]);
-            alice.crypto!.deviceList.storeCrossSigningForUser("@alice:example.com", {
-                firstUse: false,
-                crossSigningVerifiedBefore: false,
-                keys: {
-                    master: {
-                        user_id: "@alice:example.com",
-                        usage: ["master"],
-                        keys: {
-                            [`ed25519:${XSPubKey}`]: XSPubKey,
-                        },
-                    },
-                    self_signing: sign<CrossSigningKeyInfo>(
-                        {
-                            user_id: "@alice:example.com",
-                            usage: ["self_signing"],
-                            keys: {
-                                [`ed25519:${SSPubKey}`]: SSPubKey,
-                            },
-                        },
-                        XSK,
-                        "@alice:example.com",
-                    ),
-                    user_signing: sign<CrossSigningKeyInfo>(
-                        {
-                            user_id: "@alice:example.com",
-                            usage: ["user_signing"],
-                            keys: {
-                                [`ed25519:${USPubKey}`]: USPubKey,
-                            },
-                        },
-                        XSK,
-                        "@alice:example.com",
-                    ),
-                },
-            });
-            alice.getKeyBackupVersion = async () => {
-                return {
-                    version: "1",
-                    algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
-                    auth_data: sign(
-                        {
-                            public_key: "pxEXhg+4vdMf/kFwP4bVawFWdb0EmytL3eFJx++zQ0A",
-                        },
-                        XSK,
-                        "@alice:example.com",
-                    ),
-                };
-            };
-            alice.setAccountData = async function (name, data) {
-                const event = new MatrixEvent({
-                    type: name,
-                    content: data,
-                });
-                alice.store.storeAccountDataEvents([event]);
-                this.emit(ClientEvent.AccountData, event);
-                return {};
-            };
-
-            await alice.bootstrapSecretStorage({});
-
-            const backupKey = alice.getAccountData("m.megolm_backup.v1")!.getContent();
-            expect(backupKey.encrypted).toHaveProperty("key_id");
-            expect(await alice.getSecret("m.megolm_backup.v1")).toEqual("ey0GB1kB6jhOWgwiBUMIWg==");
-            alice.stopClient();
-        });
-    });
-});
@@ -17,7 +17,7 @@ limitations under the License.
 import "fake-indexeddb/auto";
 import "jest-localstorage-mock";
 import { IndexedDBCryptoStore, LocalStorageCryptoStore, MemoryCryptoStore } from "../../../../src";
-import { CryptoStore, MigrationState, SESSION_BATCH_SIZE } from "../../../../src/crypto/store/base";
+import { type CryptoStore, MigrationState, SESSION_BATCH_SIZE } from "../../../../src/crypto/store/base";

 describe.each([
    ["IndexedDBCryptoStore", () => new IndexedDBCryptoStore(globalThis.indexedDB, "tests")],
@@ -1,91 +0,0 @@
-/*
-Copyright 2020 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 { MatrixClient } from "../../../../src/client";
-import { InRoomChannel } from "../../../../src/crypto/verification/request/InRoomChannel";
-import { MatrixEvent } from "../../../../src/models/event";
-
-describe("InRoomChannel tests", function () {
-    const ALICE = "@alice:hs.tld";
-    const BOB = "@bob:hs.tld";
-    const MALORY = "@malory:hs.tld";
-    const client = {
-        getUserId() {
-            return ALICE;
-        },
-    } as unknown as MatrixClient;
-
-    it("getEventType only returns .request for a message with a msgtype", function () {
-        const invalidEvent = new MatrixEvent({
-            type: "m.key.verification.request",
-        });
-        expect(InRoomChannel.getEventType(invalidEvent)).toStrictEqual("");
-        const validEvent = new MatrixEvent({
-            type: "m.room.message",
-            content: { msgtype: "m.key.verification.request" },
-        });
-        expect(InRoomChannel.getEventType(validEvent)).toStrictEqual("m.key.verification.request");
-        const validFooEvent = new MatrixEvent({ type: "m.foo" });
-        expect(InRoomChannel.getEventType(validFooEvent)).toStrictEqual("m.foo");
-    });
-
-    it("getEventType should return m.room.message for messages", function () {
-        const messageEvent = new MatrixEvent({
-            type: "m.room.message",
-            content: { msgtype: "m.text" },
-        });
-        // XXX: The event type doesn't matter too much, just as long as it's not a verification event
-        expect(InRoomChannel.getEventType(messageEvent)).toStrictEqual("m.room.message");
-    });
-
-    it("getEventType should return actual type for non-message events", function () {
-        const event = new MatrixEvent({
-            type: "m.room.member",
-            content: {},
-        });
-        expect(InRoomChannel.getEventType(event)).toStrictEqual("m.room.member");
-    });
-
-    it("getOtherPartyUserId should not return anything for a request not " + "directed at me", function () {
-        const event = new MatrixEvent({
-            sender: BOB,
-            type: "m.room.message",
-            content: { msgtype: "m.key.verification.request", to: MALORY },
-        });
-        expect(InRoomChannel.getOtherPartyUserId(event, client)).toStrictEqual(undefined);
-    });
-
-    it("getOtherPartyUserId should not return anything an event that is not of a valid " + "request type", function () {
-        // invalid because this should be a room message with msgtype
-        const invalidRequest = new MatrixEvent({
-            sender: BOB,
-            type: "m.key.verification.request",
-            content: { to: ALICE },
-        });
-        expect(InRoomChannel.getOtherPartyUserId(invalidRequest, client)).toStrictEqual(undefined);
-        const startEvent = new MatrixEvent({
-            sender: BOB,
-            type: "m.key.verification.start",
-            content: { to: ALICE },
-        });
-        expect(InRoomChannel.getOtherPartyUserId(startEvent, client)).toStrictEqual(undefined);
-        const fooEvent = new MatrixEvent({
-            sender: BOB,
-            type: "m.foo",
-            content: { to: ALICE },
-        });
-        expect(InRoomChannel.getOtherPartyUserId(fooEvent, client)).toStrictEqual(undefined);
-    });
-});
@@ -1,41 +0,0 @@
-/*
-Copyright 2018-2019 New Vector 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.
-*/
-import "../../../olm-loader";
-import { logger } from "../../../../src/logger";
-
-const Olm = globalThis.Olm;
-
-describe("QR code verification", function () {
-    if (!globalThis.Olm) {
-        logger.warn("Not running device verification tests: libolm not present");
-        return;
-    }
-
-    beforeAll(function () {
-        return Olm.init();
-    });
-
-    describe("reciprocate", () => {
-        it("should verify the secret", () => {
-            // TODO: Actually write a test for this.
-            // Tests are hard because we are running before the verification
-            // process actually begins, and are largely UI-driven rather than
-            // logic-driven (compared to something like SAS). In the interest
-            // of time, tests are currently excluded.
-        });
-    });
-});
@@ -1,80 +0,0 @@
-/*
-Copyright 2019 New Vector 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.
-*/
-import "../../../olm-loader";
-import { CryptoEvent, verificationMethods } from "../../../../src/crypto";
-import { logger } from "../../../../src/logger";
-import { SAS } from "../../../../src/crypto/verification/SAS";
-import { makeTestClients } from "./util";
-
-const Olm = globalThis.Olm;
-
-jest.useFakeTimers();
-
-describe("verification request integration tests with crypto layer", function () {
-    if (!globalThis.Olm) {
-        logger.warn("Not running device verification unit tests: libolm not present");
-        return;
-    }
-
-    beforeAll(function () {
-        return Olm.init();
-    });
-
-    it("should request and accept a verification", async function () {
-        const [[alice, bob], clearTestClientTimeouts] = await makeTestClients(
-            [
-                { userId: "@alice:example.com", deviceId: "Osborne2" },
-                { userId: "@bob:example.com", deviceId: "Dynabook" },
-            ],
-            {
-                verificationMethods: [verificationMethods.SAS],
-            },
-        );
-        alice.client.crypto!.deviceList.getRawStoredDevicesForUser = function () {
-            return {
-                Dynabook: {
-                    algorithms: [],
-                    verified: 0,
-                    known: false,
-                    keys: {
-                        "ed25519:Dynabook": "bob+base64+ed25519+key",
-                    },
-                },
-            };
-        };
-        alice.client.downloadKeys = jest.fn().mockResolvedValue({});
-        bob.client.downloadKeys = jest.fn().mockResolvedValue({});
-        bob.client.on(CryptoEvent.VerificationRequest, (request) => {
-            const bobVerifier = request.beginKeyVerification(verificationMethods.SAS);
-            bobVerifier.verify();
-
-            // @ts-ignore Private function access (but it's a test, so we're okay)
-            bobVerifier.endTimer();
-        });
-        const aliceRequest = await alice.client.requestVerification("@bob:example.com");
-        await aliceRequest.waitFor((r) => r.started);
-        const aliceVerifier = aliceRequest.verifier;
-        expect(aliceVerifier).toBeInstanceOf(SAS);
-
-        // @ts-ignore Private function access (but it's a test, so we're okay)
-        aliceVerifier.endTimer();
-
-        alice.stop();
-        bob.stop();
-        clearTestClientTimeouts();
-    });
-});
@@ -1,581 +0,0 @@
-/*
-Copyright 2018-2019 New Vector 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.
-*/
-import "../../../olm-loader";
-import { makeTestClients } from "./util";
-import { MatrixEvent } from "../../../../src/models/event";
-import { ISasEvent, SAS, SasEvent } from "../../../../src/crypto/verification/SAS";
-import { DeviceInfo, IDevice } from "../../../../src/crypto/deviceinfo";
-import { CryptoEvent, verificationMethods } from "../../../../src/crypto";
-import * as olmlib from "../../../../src/crypto/olmlib";
-import { logger } from "../../../../src/logger";
-import { resetCrossSigningKeys } from "../crypto-utils";
-import { VerificationBase } from "../../../../src/crypto/verification/Base";
-import { IVerificationChannel } from "../../../../src/crypto/verification/request/Channel";
-import { MatrixClient } from "../../../../src";
-import { VerificationRequest } from "../../../../src/crypto/verification/request/VerificationRequest";
-import { TestClient } from "../../../TestClient";
-
-const Olm = globalThis.Olm;
-
-let ALICE_DEVICES: Record<string, IDevice>;
-let BOB_DEVICES: Record<string, IDevice>;
-
-describe("SAS verification", function () {
-    if (!globalThis.Olm) {
-        logger.warn("Not running device verification unit tests: libolm not present");
-        return;
-    }
-
-    beforeAll(function () {
-        return Olm.init();
-    });
-
-    it("should error on an unexpected event", async function () {
-        //channel, baseApis, userId, deviceId, startEvent, request
-        const request = {
-            onVerifierCancelled: function () {},
-        } as VerificationRequest;
-        const channel = {
-            send: function () {
-                return Promise.resolve();
-            },
-        } as unknown as IVerificationChannel;
-        const mockClient = {} as unknown as MatrixClient;
-        const event = new MatrixEvent({ type: "test" });
-        const sas = new SAS(channel, mockClient, "@alice:example.com", "ABCDEFG", event, request);
-        sas.handleEvent(
-            new MatrixEvent({
-                sender: "@alice:example.com",
-                type: "es.inquisition",
-                content: {},
-            }),
-        );
-        const spy = jest.fn();
-        await sas.verify().catch(spy);
-        expect(spy).toHaveBeenCalled();
-
-        // Cancel the SAS for cleanup (we started a verification, so abort)
-        sas.cancel(new Error("error"));
-    });
-
-    describe("verification", () => {
-        let alice: TestClient;
-        let bob: TestClient;
-        let aliceSasEvent: ISasEvent | null;
-        let bobSasEvent: ISasEvent | null;
-        let aliceVerifier: SAS;
-        let bobPromise: Promise<VerificationBase<any, any>>;
-        let clearTestClientTimeouts: () => void;
-
-        beforeEach(async () => {
-            [[alice, bob], clearTestClientTimeouts] = await makeTestClients(
-                [
-                    { userId: "@alice:example.com", deviceId: "Osborne2" },
-                    { userId: "@bob:example.com", deviceId: "Dynabook" },
-                ],
-                {
-                    verificationMethods: [verificationMethods.SAS],
-                },
-            );
-
-            const aliceDevice = alice.client.crypto!.olmDevice;
-            const bobDevice = bob.client.crypto!.olmDevice;
-
-            ALICE_DEVICES = {
-                Osborne2: {
-                    algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                    keys: {
-                        "ed25519:Osborne2": aliceDevice.deviceEd25519Key!,
-                        "curve25519:Osborne2": aliceDevice.deviceCurve25519Key!,
-                    },
-                    verified: DeviceInfo.DeviceVerification.UNVERIFIED,
-                    known: false,
-                },
-            };
-
-            BOB_DEVICES = {
-                Dynabook: {
-                    algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                    keys: {
-                        "ed25519:Dynabook": bobDevice.deviceEd25519Key!,
-                        "curve25519:Dynabook": bobDevice.deviceCurve25519Key!,
-                    },
-                    verified: DeviceInfo.DeviceVerification.UNVERIFIED,
-                    known: false,
-                },
-            };
-
-            alice.client.crypto!.deviceList.storeDevicesForUser("@bob:example.com", BOB_DEVICES);
-            alice.client.downloadKeys = () => {
-                return Promise.resolve(new Map());
-            };
-
-            bob.client.crypto!.deviceList.storeDevicesForUser("@alice:example.com", ALICE_DEVICES);
-            bob.client.downloadKeys = () => {
-                return Promise.resolve(new Map());
-            };
-
-            aliceSasEvent = null;
-            bobSasEvent = null;
-
-            bobPromise = new Promise<VerificationBase<any, any>>((resolve, reject) => {
-                bob.client.on(CryptoEvent.VerificationRequest, (request) => {
-                    (<SAS>request.verifier!).on(SasEvent.ShowSas, (e) => {
-                        if (!e.sas.emoji || !e.sas.decimal) {
-                            e.cancel();
-                        } else if (!aliceSasEvent) {
-                            bobSasEvent = e;
-                        } else {
-                            try {
-                                expect(e.sas).toEqual(aliceSasEvent.sas);
-                                e.confirm();
-                                aliceSasEvent.confirm();
-                            } catch {
-                                e.mismatch();
-                                aliceSasEvent.mismatch();
-                            }
-                        }
-                    });
-                    resolve(request.verifier!);
-                });
-            });
-
-            aliceVerifier = alice.client.beginKeyVerification(
-                verificationMethods.SAS,
-                bob.client.getUserId()!,
-                bob.deviceId!,
-            ) as SAS;
-            aliceVerifier.on(SasEvent.ShowSas, (e) => {
-                if (!e.sas.emoji || !e.sas.decimal) {
-                    e.cancel();
-                } else if (!bobSasEvent) {
-                    aliceSasEvent = e;
-                } else {
-                    try {
-                        expect(e.sas).toEqual(bobSasEvent.sas);
-                        e.confirm();
-                        bobSasEvent.confirm();
-                    } catch {
-                        e.mismatch();
-                        bobSasEvent.mismatch();
-                    }
-                }
-            });
-        });
-
-        afterEach(async () => {
-            await Promise.all([alice.stop(), bob.stop()]);
-
-            clearTestClientTimeouts();
-        });
-
-        it("should verify a key", async () => {
-            let macMethod;
-            let keyAgreement;
-            const origSendToDevice = bob.client.sendToDevice.bind(bob.client);
-            bob.client.sendToDevice = async (type, map) => {
-                if (type === "m.key.verification.accept") {
-                    macMethod = map
-                        .get(alice.client.getUserId()!)
-                        ?.get(alice.client.deviceId!)?.message_authentication_code;
-                    keyAgreement = map
-                        .get(alice.client.getUserId()!)
-                        ?.get(alice.client.deviceId!)?.key_agreement_protocol;
-                }
-                return origSendToDevice(type, map);
-            };
-
-            alice.httpBackend.when("POST", "/keys/query").respond(200, {
-                failures: {},
-                device_keys: {
-                    "@bob:example.com": BOB_DEVICES,
-                },
-            });
-            bob.httpBackend.when("POST", "/keys/query").respond(200, {
-                failures: {},
-                device_keys: {
-                    "@alice:example.com": ALICE_DEVICES,
-                },
-            });
-
-            await Promise.all([
-                aliceVerifier.verify(),
-                bobPromise.then((verifier) => verifier.verify()),
-                alice.httpBackend.flush(undefined),
-                bob.httpBackend.flush(undefined),
-            ]);
-
-            // make sure that it uses the preferred method
-            expect(macMethod).toBe("hkdf-hmac-sha256.v2");
-            expect(keyAgreement).toBe("curve25519-hkdf-sha256");
-
-            // make sure Alice and Bob verified each other
-            const bobDevice = await alice.client.getStoredDevice("@bob:example.com", "Dynabook");
-            expect(bobDevice?.isVerified()).toBeTruthy();
-            const aliceDevice = await bob.client.getStoredDevice("@alice:example.com", "Osborne2");
-            expect(aliceDevice?.isVerified()).toBeTruthy();
-        });
-
-        it("should be able to verify using the old base64", async () => {
-            // pretend that Alice can only understand the old (incorrect) base64
-            // encoding, and make sure that she can still verify with Bob
-            let macMethod;
-            const aliceOrigSendToDevice = alice.client.sendToDevice.bind(alice.client);
-            alice.client.sendToDevice = (type, map) => {
-                if (type === "m.key.verification.start") {
-                    // Note: this modifies not only the message that Bob
-                    // receives, but also the copy of the message that Alice
-                    // has, since it is the same object.  If this does not
-                    // happen, the verification will fail due to a hash
-                    // commitment mismatch.
-                    map.get(bob.client.getUserId()!)!.get(bob.client.deviceId!)!.message_authentication_codes = [
-                        "hkdf-hmac-sha256",
-                    ];
-                }
-                return aliceOrigSendToDevice(type, map);
-            };
-            const bobOrigSendToDevice = bob.client.sendToDevice.bind(bob.client);
-            bob.client.sendToDevice = (type, map) => {
-                if (type === "m.key.verification.accept") {
-                    macMethod = map
-                        .get(alice.client.getUserId()!)!
-                        .get(alice.client.deviceId!)!.message_authentication_code;
-                }
-                return bobOrigSendToDevice(type, map);
-            };
-
-            alice.httpBackend.when("POST", "/keys/query").respond(200, {
-                failures: {},
-                device_keys: {
-                    "@bob:example.com": BOB_DEVICES,
-                },
-            });
-            bob.httpBackend.when("POST", "/keys/query").respond(200, {
-                failures: {},
-                device_keys: {
-                    "@alice:example.com": ALICE_DEVICES,
-                },
-            });
-
-            await Promise.all([
-                aliceVerifier.verify(),
-                bobPromise.then((verifier) => verifier.verify()),
-                alice.httpBackend.flush(undefined),
-                bob.httpBackend.flush(undefined),
-            ]);
-
-            expect(macMethod).toBe("hkdf-hmac-sha256");
-
-            const bobDevice = await alice.client.getStoredDevice("@bob:example.com", "Dynabook");
-            expect(bobDevice!.isVerified()).toBeTruthy();
-            const aliceDevice = await bob.client.getStoredDevice("@alice:example.com", "Osborne2");
-            expect(aliceDevice!.isVerified()).toBeTruthy();
-        });
-
-        it("should be able to verify using the old MAC", async () => {
-            // pretend that Alice can only understand the old (incorrect) MAC,
-            // and make sure that she can still verify with Bob
-            let macMethod;
-            const aliceOrigSendToDevice = alice.client.sendToDevice.bind(alice.client);
-            alice.client.sendToDevice = (type, map) => {
-                if (type === "m.key.verification.start") {
-                    // Note: this modifies not only the message that Bob
-                    // receives, but also the copy of the message that Alice
-                    // has, since it is the same object.  If this does not
-                    // happen, the verification will fail due to a hash
-                    // commitment mismatch.
-                    map.get(bob.client.getUserId()!)!.get(bob.client.deviceId!)!.message_authentication_codes = [
-                        "hmac-sha256",
-                    ];
-                }
-                return aliceOrigSendToDevice(type, map);
-            };
-            const bobOrigSendToDevice = bob.client.sendToDevice.bind(bob.client);
-            bob.client.sendToDevice = (type, map) => {
-                if (type === "m.key.verification.accept") {
-                    macMethod = map
-                        .get(alice.client.getUserId()!)!
-                        .get(alice.client.deviceId!)!.message_authentication_code;
-                }
-                return bobOrigSendToDevice(type, map);
-            };
-
-            alice.httpBackend.when("POST", "/keys/query").respond(200, {
-                failures: {},
-                device_keys: {
-                    "@bob:example.com": BOB_DEVICES,
-                },
-            });
-            bob.httpBackend.when("POST", "/keys/query").respond(200, {
-                failures: {},
-                device_keys: {
-                    "@alice:example.com": ALICE_DEVICES,
-                },
-            });
-
-            await Promise.all([
-                aliceVerifier.verify(),
-                bobPromise.then((verifier) => verifier.verify()),
-                alice.httpBackend.flush(undefined),
-                bob.httpBackend.flush(undefined),
-            ]);
-
-            expect(macMethod).toBe("hmac-sha256");
-
-            const bobDevice = await alice.client.getStoredDevice("@bob:example.com", "Dynabook");
-            expect(bobDevice?.isVerified()).toBeTruthy();
-            const aliceDevice = await bob.client.getStoredDevice("@alice:example.com", "Osborne2");
-            expect(aliceDevice?.isVerified()).toBeTruthy();
-        });
-
-        it("should verify a cross-signing key", async () => {
-            alice.httpBackend.when("POST", "/keys/device_signing/upload").respond(200, {});
-            alice.httpBackend.when("POST", "/keys/signatures/upload").respond(200, {});
-            alice.httpBackend.flush(undefined, 2);
-            await resetCrossSigningKeys(alice.client);
-            bob.httpBackend.when("POST", "/keys/device_signing/upload").respond(200, {});
-            bob.httpBackend.when("POST", "/keys/signatures/upload").respond(200, {});
-            bob.httpBackend.flush(undefined, 2);
-
-            await resetCrossSigningKeys(bob.client);
-
-            bob.client.crypto!.deviceList.storeCrossSigningForUser("@alice:example.com", {
-                keys: alice.client.crypto!.crossSigningInfo.keys,
-                crossSigningVerifiedBefore: false,
-                firstUse: true,
-            });
-
-            const verifyProm = Promise.all([
-                aliceVerifier.verify(),
-                bobPromise.then((verifier) => {
-                    bob.httpBackend.when("POST", "/keys/signatures/upload").respond(200, {});
-                    bob.httpBackend.flush(undefined, 1, 2000);
-                    return verifier.verify();
-                }),
-            ]);
-
-            await verifyProm;
-
-            const bobDeviceTrust = alice.client.checkDeviceTrust("@bob:example.com", "Dynabook");
-            expect(bobDeviceTrust.isLocallyVerified()).toBeTruthy();
-            expect(bobDeviceTrust.isCrossSigningVerified()).toBeFalsy();
-
-            const bobDeviceVerificationStatus = (await alice.client
-                .getCrypto()!
-                .getDeviceVerificationStatus("@bob:example.com", "Dynabook"))!;
-            expect(bobDeviceVerificationStatus.localVerified).toBe(true);
-            expect(bobDeviceVerificationStatus.crossSigningVerified).toBe(false);
-
-            const aliceTrust = bob.client.checkUserTrust("@alice:example.com");
-            expect(aliceTrust.isCrossSigningVerified()).toBeTruthy();
-            expect(aliceTrust.isTofu()).toBeTruthy();
-
-            const aliceDeviceTrust = bob.client.checkDeviceTrust("@alice:example.com", "Osborne2");
-            expect(aliceDeviceTrust.isLocallyVerified()).toBeTruthy();
-            expect(aliceDeviceTrust.isCrossSigningVerified()).toBeFalsy();
-
-            const aliceDeviceVerificationStatus = (await bob.client
-                .getCrypto()!
-                .getDeviceVerificationStatus("@alice:example.com", "Osborne2"))!;
-            expect(aliceDeviceVerificationStatus.localVerified).toBe(true);
-            expect(aliceDeviceVerificationStatus.crossSigningVerified).toBe(false);
-
-            const unknownDeviceVerificationStatus = await bob.client
-                .getCrypto()!
-                .getDeviceVerificationStatus("@alice:example.com", "xyz");
-            expect(unknownDeviceVerificationStatus).toBe(null);
-        });
-    });
-
-    it("should send a cancellation message on error", async function () {
-        const [[alice, bob], clearTestClientTimeouts] = await makeTestClients(
-            [
-                { userId: "@alice:example.com", deviceId: "Osborne2" },
-                { userId: "@bob:example.com", deviceId: "Dynabook" },
-            ],
-            {
-                verificationMethods: [verificationMethods.SAS],
-            },
-        );
-        alice.client.setDeviceVerified = jest.fn();
-        alice.client.downloadKeys = jest.fn().mockResolvedValue({});
-        bob.client.setDeviceVerified = jest.fn();
-        bob.client.downloadKeys = jest.fn().mockResolvedValue({});
-
-        const bobPromise = new Promise<VerificationBase<any, any>>((resolve, reject) => {
-            bob.client.on(CryptoEvent.VerificationRequest, (request) => {
-                (<SAS>request.verifier!).on(SasEvent.ShowSas, (e) => {
-                    e.mismatch();
-                });
-                resolve(request.verifier!);
-            });
-        });
-
-        const aliceVerifier = alice.client.beginKeyVerification(
-            verificationMethods.SAS,
-            bob.client.getUserId()!,
-            bob.client.deviceId!,
-        );
-
-        const aliceSpy = jest.fn();
-        const bobSpy = jest.fn();
-        await Promise.all([
-            aliceVerifier.verify().catch(aliceSpy),
-            bobPromise.then((verifier) => verifier.verify()).catch(bobSpy),
-        ]);
-        expect(aliceSpy).toHaveBeenCalled();
-        expect(bobSpy).toHaveBeenCalled();
-        expect(alice.client.setDeviceVerified).not.toHaveBeenCalled();
-        expect(bob.client.setDeviceVerified).not.toHaveBeenCalled();
-
-        alice.stop();
-        bob.stop();
-        clearTestClientTimeouts();
-    });
-
-    describe("verification in DM", function () {
-        let alice: TestClient;
-        let bob: TestClient;
-        let aliceSasEvent: ISasEvent | null;
-        let bobSasEvent: ISasEvent | null;
-        let aliceVerifier: SAS;
-        let bobPromise: Promise<void>;
-        let clearTestClientTimeouts: () => void;
-
-        beforeEach(async function () {
-            [[alice, bob], clearTestClientTimeouts] = await makeTestClients(
-                [
-                    { userId: "@alice:example.com", deviceId: "Osborne2" },
-                    { userId: "@bob:example.com", deviceId: "Dynabook" },
-                ],
-                {
-                    verificationMethods: [verificationMethods.SAS],
-                },
-            );
-
-            alice.client.crypto!.setDeviceVerification = jest.fn();
-            alice.client.getDeviceEd25519Key = () => {
-                return "alice+base64+ed25519+key";
-            };
-            alice.client.getStoredDevice = () => {
-                return DeviceInfo.fromStorage(
-                    {
-                        keys: {
-                            "ed25519:Dynabook": "bob+base64+ed25519+key",
-                        },
-                    },
-                    "Dynabook",
-                );
-            };
-            alice.client.downloadKeys = () => {
-                return Promise.resolve(new Map());
-            };
-
-            bob.client.crypto!.setDeviceVerification = jest.fn();
-            bob.client.getStoredDevice = () => {
-                return DeviceInfo.fromStorage(
-                    {
-                        keys: {
-                            "ed25519:Osborne2": "alice+base64+ed25519+key",
-                        },
-                    },
-                    "Osborne2",
-                );
-            };
-            bob.client.getDeviceEd25519Key = () => {
-                return "bob+base64+ed25519+key";
-            };
-            bob.client.downloadKeys = () => {
-                return Promise.resolve(new Map());
-            };
-
-            aliceSasEvent = null;
-            bobSasEvent = null;
-
-            bobPromise = new Promise<void>((resolve, reject) => {
-                bob.client.on(CryptoEvent.VerificationRequest, async (request) => {
-                    const verifier = request.beginKeyVerification(SAS.NAME) as SAS;
-                    verifier.on(SasEvent.ShowSas, (e) => {
-                        if (!e.sas.emoji || !e.sas.decimal) {
-                            e.cancel();
-                        } else if (!aliceSasEvent) {
-                            bobSasEvent = e;
-                        } else {
-                            try {
-                                expect(e.sas).toEqual(aliceSasEvent.sas);
-                                e.confirm();
-                                aliceSasEvent.confirm();
-                            } catch {
-                                e.mismatch();
-                                aliceSasEvent.mismatch();
-                            }
-                        }
-                    });
-                    await verifier.verify();
-                    resolve();
-                });
-            });
-
-            const aliceRequest = await alice.client.requestVerificationDM(bob.client.getUserId()!, "!room_id");
-            await aliceRequest.waitFor((r) => r.started);
-            aliceVerifier = aliceRequest.verifier! as SAS;
-            aliceVerifier.on(SasEvent.ShowSas, (e) => {
-                if (!e.sas.emoji || !e.sas.decimal) {
-                    e.cancel();
-                } else if (!bobSasEvent) {
-                    aliceSasEvent = e;
-                } else {
-                    try {
-                        expect(e.sas).toEqual(bobSasEvent.sas);
-                        e.confirm();
-                        bobSasEvent.confirm();
-                    } catch {
-                        e.mismatch();
-                        bobSasEvent.mismatch();
-                    }
-                }
-            });
-        });
-        afterEach(async function () {
-            await Promise.all([alice.stop(), bob.stop()]);
-
-            clearTestClientTimeouts();
-        });
-
-        it("should verify a key", async function () {
-            await Promise.all([aliceVerifier.verify(), bobPromise]);
-
-            // make sure Alice and Bob verified each other
-            expect(alice.client.crypto!.setDeviceVerification).toHaveBeenCalledWith(
-                bob.client.getUserId(),
-                bob.client.deviceId,
-                true,
-                null,
-                null,
-                { "ed25519:Dynabook": "bob+base64+ed25519+key" },
-            );
-            expect(bob.client.crypto!.setDeviceVerification).toHaveBeenCalledWith(
-                alice.client.getUserId(),
-                alice.client.deviceId,
-                true,
-                null,
-                null,
-                { "ed25519:Osborne2": "alice+base64+ed25519+key" },
-            );
-        });
-    });
-});
@@ -1,122 +0,0 @@
-/*
-Copyright 2020 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import "../../../olm-loader";
-import { MatrixClient, MatrixEvent } from "../../../../src/matrix";
-import { encodeBase64 } from "../../../../src/base64";
-import "../../../../src/crypto"; // import this to cycle-break
-import { CrossSigningInfo } from "../../../../src/crypto/CrossSigning";
-import { VerificationRequest } from "../../../../src/crypto/verification/request/VerificationRequest";
-import { IVerificationChannel } from "../../../../src/crypto/verification/request/Channel";
-import { VerificationBase } from "../../../../src/crypto/verification/Base";
-
-jest.useFakeTimers();
-
-// Private key for tests only
-const testKey = new Uint8Array([
-    0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82, 0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef, 0xae, 0xb1, 0x05,
-    0xc1, 0xe7, 0x62, 0x78, 0xa6, 0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
-]);
-const testKeyPub = "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk";
-
-describe("self-verifications", () => {
-    beforeAll(function () {
-        return globalThis.Olm.init();
-    });
-
-    it("triggers a request for key sharing upon completion", async () => {
-        const userId = "@test:localhost";
-
-        const cacheCallbacks = {
-            getCrossSigningKeyCache: jest.fn().mockReturnValue(null),
-            storeCrossSigningKeyCache: jest.fn(),
-        };
-
-        const crossSigningInfo = new CrossSigningInfo(userId, {}, cacheCallbacks);
-        crossSigningInfo.keys = {
-            master: {
-                keys: { X: testKeyPub },
-                usage: [],
-                user_id: "user-id",
-            },
-            self_signing: {
-                keys: { X: testKeyPub },
-                usage: [],
-                user_id: "user-id",
-            },
-            user_signing: {
-                keys: { X: testKeyPub },
-                usage: [],
-                user_id: "user-id",
-            },
-        };
-
-        const secretStorage = {
-            request: jest.fn().mockReturnValue({
-                promise: Promise.resolve(encodeBase64(testKey)),
-            }),
-        };
-
-        const storeSessionBackupPrivateKey = jest.fn();
-        const restoreKeyBackupWithCache = jest.fn(() => Promise.resolve());
-
-        const client = {
-            crypto: {
-                crossSigningInfo,
-                secretStorage,
-                storeSessionBackupPrivateKey,
-                getSessionBackupPrivateKey: () => null,
-            },
-            requestSecret: secretStorage.request.bind(secretStorage),
-            getUserId: () => userId,
-            getKeyBackupVersion: () => Promise.resolve({}),
-            restoreKeyBackupWithCache,
-        } as unknown as MatrixClient;
-
-        const request = {
-            onVerifierFinished: () => undefined,
-        } as unknown as VerificationRequest;
-
-        const verification = new VerificationBase(
-            undefined as unknown as IVerificationChannel, // channel
-            client, // baseApis
-            userId,
-            "ABC", // deviceId
-            undefined as unknown as MatrixEvent, // startEvent
-            request,
-        );
-
-        // @ts-ignore set private property
-        verification.resolve = () => undefined;
-
-        const result = await verification.done();
-
-        /* We should request, and store, 3 cross signing keys and the key backup key */
-        expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls.length).toBe(3);
-        expect(secretStorage.request.mock.calls.length).toBe(4);
-
-        expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls[0][1]).toEqual(testKey);
-        expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls[1][1]).toEqual(testKey);
-
-        expect(storeSessionBackupPrivateKey.mock.calls[0][0]).toEqual(testKey);
-
-        expect(restoreKeyBackupWithCache).toHaveBeenCalled();
-
-        expect(result).toBeInstanceOf(Array);
-        expect(result![0][0]).toBe(testKeyPub);
-        expect(result![1][0]).toBe(testKeyPub);
-    });
-});
@@ -1,129 +0,0 @@
-/*
-Copyright 2019 New Vector 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.
-*/
-
-import { TestClient } from "../../../TestClient";
-import { IContent, MatrixEvent } from "../../../../src/models/event";
-import { IRoomTimelineData } from "../../../../src/models/event-timeline-set";
-import { Room, RoomEvent } from "../../../../src/models/room";
-import { logger } from "../../../../src/logger";
-import { MatrixClient, ClientEvent, ICreateClientOpts, SendToDeviceContentMap } from "../../../../src/client";
-
-interface UserInfo {
-    userId: string;
-    deviceId: string;
-}
-
-export async function makeTestClients(
-    userInfos: UserInfo[],
-    options: Partial<ICreateClientOpts>,
-): Promise<[TestClient[], () => void]> {
-    const clients: TestClient[] = [];
-    const timeouts: ReturnType<typeof setTimeout>[] = [];
-    const clientMap: Record<string, Record<string, MatrixClient>> = {};
-    const makeSendToDevice =
-        (matrixClient: MatrixClient): MatrixClient["sendToDevice"] =>
-        async (type: string, contentMap: SendToDeviceContentMap) => {
-            // logger.log(this.getUserId(), "sends", type, map);
-            for (const [userId, deviceMessages] of contentMap) {
-                if (userId in clientMap) {
-                    for (const [deviceId, message] of deviceMessages) {
-                        if (deviceId in clientMap[userId]) {
-                            const event = new MatrixEvent({
-                                sender: matrixClient.getUserId()!,
-                                type: type,
-                                content: message,
-                            });
-                            const client = clientMap[userId][deviceId];
-                            const decryptionPromise = event.isEncrypted()
-                                ? event.attemptDecryption(client.crypto!)
-                                : Promise.resolve();
-
-                            decryptionPromise.then(() => client.emit(ClientEvent.ToDeviceEvent, event));
-                        }
-                    }
-                }
-            }
-            return {};
-        };
-    const makeSendEvent = (matrixClient: MatrixClient) => (room: string, type: string, content: IContent) => {
-        // make up a unique ID as the event ID
-        const eventId = "$" + matrixClient.makeTxnId();
-        const rawEvent = {
-            sender: matrixClient.getUserId()!,
-            type: type,
-            content: content,
-            room_id: room,
-            event_id: eventId,
-            origin_server_ts: Date.now(),
-        };
-        const event = new MatrixEvent(rawEvent);
-        const remoteEcho = new MatrixEvent(
-            Object.assign({}, rawEvent, {
-                unsigned: {
-                    transaction_id: matrixClient.makeTxnId(),
-                },
-            }),
-        );
-
-        const timeout = setTimeout(() => {
-            for (const tc of clients) {
-                const room = new Room("test", tc.client, tc.client.getUserId()!);
-                const roomTimelineData = {} as unknown as IRoomTimelineData;
-                if (tc.client === matrixClient) {
-                    logger.log("sending remote echo!!");
-                    tc.client.emit(RoomEvent.Timeline, remoteEcho, room, false, false, roomTimelineData);
-                } else {
-                    tc.client.emit(RoomEvent.Timeline, event, room, false, false, roomTimelineData);
-                }
-            }
-        });
-
-        timeouts.push(timeout as unknown as ReturnType<typeof setTimeout>);
-
-        return Promise.resolve({ event_id: eventId });
-    };
-
-    for (const userInfo of userInfos) {
-        let keys: Record<string, Uint8Array> = {};
-        if (!options) options = {};
-        if (!options.cryptoCallbacks) options.cryptoCallbacks = {};
-        if (!options.cryptoCallbacks.saveCrossSigningKeys) {
-            options.cryptoCallbacks.saveCrossSigningKeys = (k) => {
-                keys = k;
-            };
-            // @ts-ignore tsc getting confused by overloads
-            options.cryptoCallbacks.getCrossSigningKey = (typ) => keys[typ];
-        }
-        const testClient = new TestClient(userInfo.userId, userInfo.deviceId, undefined, undefined, options);
-        if (!(userInfo.userId in clientMap)) {
-            clientMap[userInfo.userId] = {};
-        }
-        clientMap[userInfo.userId][userInfo.deviceId] = testClient.client;
-        testClient.client.sendToDevice = makeSendToDevice(testClient.client);
-        // @ts-ignore tsc getting confused by overloads
-        testClient.client.sendEvent = makeSendEvent(testClient.client);
-        clients.push(testClient);
-    }
-
-    await Promise.all(clients.map((testClient) => testClient.client.initLegacyCrypto()));
-
-    const destroy = () => {
-        timeouts.forEach((t) => clearTimeout(t));
-    };
-
-    return [clients, destroy];
-}
@@ -1,331 +0,0 @@
-/*
-Copyright 2020 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 {
-    VerificationRequest,
-    READY_TYPE,
-    START_TYPE,
-    DONE_TYPE,
-} from "../../../../src/crypto/verification/request/VerificationRequest";
-import { InRoomChannel } from "../../../../src/crypto/verification/request/InRoomChannel";
-import { ToDeviceChannel } from "../../../../src/crypto/verification/request/ToDeviceChannel";
-import { IContent, MatrixEvent } from "../../../../src/models/event";
-import { MatrixClient } from "../../../../src/client";
-import { IVerificationChannel } from "../../../../src/crypto/verification/request/Channel";
-import { VerificationBase } from "../../../../src/crypto/verification/Base";
-import { MapWithDefault } from "../../../../src/utils";
-
-type MockClient = MatrixClient & {
-    popEvents: () => MatrixEvent[];
-    popDeviceEvents: (userId: string, deviceId: string) => MatrixEvent[];
-};
-function makeMockClient(userId: string, deviceId: string): MockClient {
-    let counter = 1;
-    let events: MatrixEvent[] = [];
-    const deviceEvents: MapWithDefault<string, MapWithDefault<string, MatrixEvent[]>> = new MapWithDefault(
-        () => new MapWithDefault(() => []),
-    );
-    return {
-        getUserId() {
-            return userId;
-        },
-        getDeviceId() {
-            return deviceId;
-        },
-
-        sendEvent(roomId: string, type: string, content: IContent) {
-            counter = counter + 1;
-            const eventId = `$${userId}-${deviceId}-${counter}`;
-            events.push(
-                new MatrixEvent({
-                    sender: userId,
-                    event_id: eventId,
-                    room_id: roomId,
-                    type,
-                    content,
-                    origin_server_ts: Date.now(),
-                }),
-            );
-            return Promise.resolve({ event_id: eventId });
-        },
-
-        sendToDevice(type: string, msgMap: Map<string, Map<string, IContent>>) {
-            for (const [userId, deviceMessages] of msgMap) {
-                for (const [deviceId, content] of deviceMessages) {
-                    const event = new MatrixEvent({ content, type });
-                    deviceEvents.getOrCreate(userId).getOrCreate(deviceId).push(event);
-                }
-            }
-            return Promise.resolve({});
-        },
-
-        // @ts-ignore special testing fn
-        popEvents(): MatrixEvent[] {
-            const e = events;
-            events = [];
-            return e;
-        },
-
-        popDeviceEvents(userId: string, deviceId: string): MatrixEvent[] {
-            const result = deviceEvents.get(userId)?.get(deviceId) || [];
-            deviceEvents?.get(userId)?.delete(deviceId);
-            return result;
-        },
-    } as unknown as MockClient;
-}
-
-const MOCK_METHOD = "mock-verify";
-class MockVerifier extends VerificationBase<"", any> {
-    public _channel;
-    public _startEvent;
-    constructor(
-        channel: IVerificationChannel,
-        client: MatrixClient,
-        userId: string,
-        deviceId: string,
-        startEvent: MatrixEvent,
-    ) {
-        super(channel, client, userId, deviceId, startEvent, {} as unknown as VerificationRequest);
-        this._channel = channel;
-        this._startEvent = startEvent;
-    }
-
-    get events() {
-        return [DONE_TYPE];
-    }
-
-    async start() {
-        if (this._startEvent) {
-            await this._channel.send(DONE_TYPE, {});
-        } else {
-            await this._channel.send(START_TYPE, { method: MOCK_METHOD });
-        }
-    }
-
-    async handleEvent(event: MatrixEvent) {
-        if (event.getType() === DONE_TYPE && !this._startEvent) {
-            await this._channel.send(DONE_TYPE, {});
-        }
-    }
-
-    canSwitchStartEvent() {
-        return false;
-    }
-}
-
-function makeRemoteEcho(event: MatrixEvent) {
-    return new MatrixEvent(
-        Object.assign({}, event.event, {
-            unsigned: {
-                transaction_id: "abc",
-            },
-        }),
-    );
-}
-
-async function distributeEvent(
-    ownRequest: VerificationRequest,
-    theirRequest: VerificationRequest,
-    event: MatrixEvent,
-): Promise<void> {
-    await ownRequest.channel.handleEvent(makeRemoteEcho(event), ownRequest, true);
-    await theirRequest.channel.handleEvent(event, theirRequest, true);
-}
-
-jest.useFakeTimers();
-
-describe("verification request unit tests", function () {
-    it("transition from UNSENT to DONE through happy path", async function () {
-        const alice = makeMockClient("@alice:matrix.tld", "device1");
-        const bob = makeMockClient("@bob:matrix.tld", "device1");
-        const verificationMethods = new Map([[MOCK_METHOD, MockVerifier]]) as unknown as Map<
-            string,
-            typeof VerificationBase
-        >;
-        const aliceRequest = new VerificationRequest(
-            new InRoomChannel(alice, "!room", bob.getUserId()!),
-            verificationMethods,
-            alice,
-        );
-        const bobRequest = new VerificationRequest(new InRoomChannel(bob, "!room"), verificationMethods, bob);
-        expect(aliceRequest.invalid).toBe(true);
-        expect(bobRequest.invalid).toBe(true);
-
-        await aliceRequest.sendRequest();
-        const [requestEvent] = alice.popEvents();
-        expect(requestEvent.getType()).toBe("m.room.message");
-        await distributeEvent(aliceRequest, bobRequest, requestEvent);
-        expect(aliceRequest.requested).toBe(true);
-        expect(bobRequest.requested).toBe(true);
-
-        await bobRequest.accept();
-        const [readyEvent] = bob.popEvents();
-        expect(readyEvent.getType()).toBe(READY_TYPE);
-        await distributeEvent(bobRequest, aliceRequest, readyEvent);
-        expect(bobRequest.ready).toBe(true);
-        expect(aliceRequest.ready).toBe(true);
-
-        const verifier = aliceRequest.beginKeyVerification(MOCK_METHOD);
-        await (verifier as MockVerifier).start();
-        const [startEvent] = alice.popEvents();
-        expect(startEvent.getType()).toBe(START_TYPE);
-        await distributeEvent(aliceRequest, bobRequest, startEvent);
-        expect(aliceRequest.started).toBe(true);
-        expect(aliceRequest.verifier).toBeInstanceOf(MockVerifier);
-        expect(bobRequest.started).toBe(true);
-        expect(bobRequest.verifier).toBeInstanceOf(MockVerifier);
-        await (bobRequest.verifier as MockVerifier).start();
-        const [bobDoneEvent] = bob.popEvents();
-        expect(bobDoneEvent.getType()).toBe(DONE_TYPE);
-        await distributeEvent(bobRequest, aliceRequest, bobDoneEvent);
-        const [aliceDoneEvent] = alice.popEvents();
-        expect(aliceDoneEvent.getType()).toBe(DONE_TYPE);
-        await distributeEvent(aliceRequest, bobRequest, aliceDoneEvent);
-        expect(aliceRequest.done).toBe(true);
-        expect(bobRequest.done).toBe(true);
-    });
-
-    it("methods only contains common methods", async function () {
-        const alice = makeMockClient("@alice:matrix.tld", "device1");
-        const bob = makeMockClient("@bob:matrix.tld", "device1");
-        const aliceVerificationMethods = new Map([
-            ["c", function () {}],
-            ["a", function () {}],
-        ]) as unknown as Map<string, typeof VerificationBase>;
-        const bobVerificationMethods = new Map([
-            ["c", function () {}],
-            ["b", function () {}],
-        ]) as unknown as Map<string, typeof VerificationBase>;
-        const aliceRequest = new VerificationRequest(
-            new InRoomChannel(alice, "!room", bob.getUserId()!),
-            aliceVerificationMethods,
-            alice,
-        );
-        const bobRequest = new VerificationRequest(new InRoomChannel(bob, "!room"), bobVerificationMethods, bob);
-        await aliceRequest.sendRequest();
-        const [requestEvent] = alice.popEvents();
-        await distributeEvent(aliceRequest, bobRequest, requestEvent);
-        await bobRequest.accept();
-        const [readyEvent] = bob.popEvents();
-        await distributeEvent(bobRequest, aliceRequest, readyEvent);
-        expect(aliceRequest.methods).toStrictEqual(["c"]);
-        expect(bobRequest.methods).toStrictEqual(["c"]);
-    });
-
-    it("other client accepting request puts it in observeOnly mode", async function () {
-        const alice = makeMockClient("@alice:matrix.tld", "device1");
-        const bob1 = makeMockClient("@bob:matrix.tld", "device1");
-        const bob2 = makeMockClient("@bob:matrix.tld", "device2");
-        const aliceRequest = new VerificationRequest(
-            new InRoomChannel(alice, "!room", bob1.getUserId()!),
-            new Map(),
-            alice,
-        );
-        await aliceRequest.sendRequest();
-        const [requestEvent] = alice.popEvents();
-        const bob1Request = new VerificationRequest(new InRoomChannel(bob1, "!room"), new Map(), bob1);
-        const bob2Request = new VerificationRequest(new InRoomChannel(bob2, "!room"), new Map(), bob2);
-
-        await bob1Request.channel.handleEvent(requestEvent, bob1Request, true);
-        await bob2Request.channel.handleEvent(requestEvent, bob2Request, true);
-
-        await bob1Request.accept();
-        const [readyEvent] = bob1.popEvents();
-        expect(bob2Request.observeOnly).toBe(false);
-        await bob2Request.channel.handleEvent(readyEvent, bob2Request, true);
-        expect(bob2Request.observeOnly).toBe(true);
-    });
-
-    it("verify own device with to_device messages", async function () {
-        const bob1 = makeMockClient("@bob:matrix.tld", "device1");
-        const bob2 = makeMockClient("@bob:matrix.tld", "device2");
-        const verificationMethods = new Map([[MOCK_METHOD, MockVerifier]]) as unknown as Map<
-            string,
-            typeof VerificationBase
-        >;
-        const bob1Request = new VerificationRequest(
-            new ToDeviceChannel(
-                bob1,
-                bob1.getUserId()!,
-                ["device1", "device2"],
-                ToDeviceChannel.makeTransactionId(),
-                "device2",
-            ),
-            verificationMethods,
-            bob1,
-        );
-        const to = { userId: "@bob:matrix.tld", deviceId: "device2" };
-        const verifier = bob1Request.beginKeyVerification(MOCK_METHOD, to);
-        expect(verifier).toBeInstanceOf(MockVerifier);
-        await (verifier as MockVerifier).start();
-        const [startEvent] = bob1.popDeviceEvents(to.userId, to.deviceId);
-        expect(startEvent.getType()).toBe(START_TYPE);
-        const bob2Request = new VerificationRequest(
-            new ToDeviceChannel(bob2, bob2.getUserId()!, ["device1"]),
-            verificationMethods,
-            bob2,
-        );
-
-        await bob2Request.channel.handleEvent(startEvent, bob2Request, true);
-        await (bob2Request.verifier as MockVerifier).start();
-        const [doneEvent1] = bob2.popDeviceEvents("@bob:matrix.tld", "device1");
-        expect(doneEvent1.getType()).toBe(DONE_TYPE);
-        await bob1Request.channel.handleEvent(doneEvent1, bob1Request, true);
-        const [doneEvent2] = bob1.popDeviceEvents("@bob:matrix.tld", "device2");
-        expect(doneEvent2.getType()).toBe(DONE_TYPE);
-        await bob2Request.channel.handleEvent(doneEvent2, bob2Request, true);
-
-        expect(bob1Request.done).toBe(true);
-        expect(bob2Request.done).toBe(true);
-    });
-
-    it("request times out after 10 minutes", async function () {
-        const alice = makeMockClient("@alice:matrix.tld", "device1");
-        const bob = makeMockClient("@bob:matrix.tld", "device1");
-        const aliceRequest = new VerificationRequest(
-            new InRoomChannel(alice, "!room", bob.getUserId()!),
-            new Map(),
-            alice,
-        );
-        await aliceRequest.sendRequest();
-        const [requestEvent] = alice.popEvents();
-        await aliceRequest.channel.handleEvent(requestEvent, aliceRequest, true);
-
-        expect(aliceRequest.cancelled).toBe(false);
-        expect(aliceRequest._cancellingUserId).toBe(undefined);
-        jest.advanceTimersByTime(10 * 60 * 1000);
-        expect(aliceRequest._cancellingUserId).toBe(alice.getUserId());
-    });
-
-    it("request times out 2 minutes after receipt", async function () {
-        const alice = makeMockClient("@alice:matrix.tld", "device1");
-        const bob = makeMockClient("@bob:matrix.tld", "device1");
-        const aliceRequest = new VerificationRequest(
-            new InRoomChannel(alice, "!room", bob.getUserId()!),
-            new Map(),
-            alice,
-        );
-        await aliceRequest.sendRequest();
-        const [requestEvent] = alice.popEvents();
-        const bobRequest = new VerificationRequest(new InRoomChannel(bob, "!room"), new Map(), bob);
-
-        await bobRequest.channel.handleEvent(requestEvent, bobRequest, true);
-
-        expect(bobRequest.cancelled).toBe(false);
-        expect(bobRequest._cancellingUserId).toBe(undefined);
-        jest.advanceTimersByTime(2 * 60 * 1000);
-        expect(bobRequest._cancellingUserId).toBe(bob.getUserId());
-    });
-});
@@ -22,25 +22,24 @@ limitations under the License.
 // project, which doesn't know about our TypeEventEmitter implementation at all
 // eslint-disable-next-line no-restricted-imports
 import { EventEmitter } from "events";
-import { MockedObject } from "jest-mock";
+import { type MockedObject } from "jest-mock";
 import {
-    WidgetApi,
+    type WidgetApi,
    WidgetApiToWidgetAction,
    MatrixCapabilities,
-    ITurnServer,
-    IRoomEvent,
-    IOpenIDCredentials,
-    ISendEventFromWidgetResponseData,
+    type ITurnServer,
+    type IRoomEvent,
+    type IOpenIDCredentials,
+    type ISendEventFromWidgetResponseData,
    WidgetApiResponseError,
 } from "matrix-widget-api";

 import { createRoomWidgetClient, MatrixError, MsgType, UpdateDelayedEventAction } from "../../src/matrix";
-import { MatrixClient, ClientEvent, ITurnServer as IClientTurnServer } from "../../src/client";
+import { MatrixClient, ClientEvent, type ITurnServer as IClientTurnServer } from "../../src/client";
 import { SyncState } from "../../src/sync";
-import { ICapabilities, RoomWidgetClient } from "../../src/embedded";
+import { type ICapabilities, type RoomWidgetClient } from "../../src/embedded";
 import { MatrixEvent } from "../../src/models/event";
-import { ToDeviceBatch } from "../../src/models/ToDeviceMessage";
-import { DeviceInfo } from "../../src/crypto/deviceinfo";
+import { type ToDeviceBatch } from "../../src/models/ToDeviceMessage";
 import { sleep } from "../../src/utils";

 const testOIDCToken = {
@@ -50,26 +49,26 @@ const testOIDCToken = {
    token_type: "Bearer",
 };
 class MockWidgetApi extends EventEmitter {
-    public start = jest.fn();
-    public requestCapability = jest.fn();
-    public requestCapabilities = jest.fn();
-    public requestCapabilityForRoomTimeline = jest.fn();
-    public requestCapabilityToSendEvent = jest.fn();
-    public requestCapabilityToReceiveEvent = jest.fn();
-    public requestCapabilityToSendMessage = jest.fn();
-    public requestCapabilityToReceiveMessage = jest.fn();
-    public requestCapabilityToSendState = jest.fn();
-    public requestCapabilityToReceiveState = jest.fn();
-    public requestCapabilityToSendToDevice = jest.fn();
-    public requestCapabilityToReceiveToDevice = jest.fn();
+    public start = jest.fn().mockResolvedValue(undefined);
+    public requestCapability = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilities = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilityForRoomTimeline = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilityToSendEvent = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilityToReceiveEvent = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilityToSendMessage = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilityToReceiveMessage = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilityToSendState = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilityToReceiveState = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilityToSendToDevice = jest.fn().mockResolvedValue(undefined);
+    public requestCapabilityToReceiveToDevice = jest.fn().mockResolvedValue(undefined);
    public sendRoomEvent = jest.fn(
-        (eventType: string, content: unknown, roomId?: string, delay?: number, parentDelayId?: string) =>
+        async (eventType: string, content: unknown, roomId?: string, delay?: number, parentDelayId?: string) =>
            delay === undefined && parentDelayId === undefined
                ? { event_id: `$${Math.random()}` }
                : { delay_id: `id-${Math.random()}` },
    );
    public sendStateEvent = jest.fn(
-        (
+        async (
            eventType: string,
            stateKey: string,
            content: unknown,
@@ -81,17 +80,17 @@ class MockWidgetApi extends EventEmitter {
                ? { event_id: `$${Math.random()}` }
                : { delay_id: `id-${Math.random()}` },
    );
-    public updateDelayedEvent = jest.fn();
-    public sendToDevice = jest.fn();
-    public requestOpenIDConnectToken = jest.fn(() => {
+    public updateDelayedEvent = jest.fn().mockResolvedValue(undefined);
+    public sendToDevice = jest.fn().mockResolvedValue(undefined);
+    public requestOpenIDConnectToken = jest.fn(async () => {
        return testOIDCToken;
        return new Promise<IOpenIDCredentials>(() => {
            return testOIDCToken;
        });
    });
-    public readStateEvents = jest.fn(() => []);
-    public getTurnServers = jest.fn(() => []);
-    public sendContentLoaded = jest.fn();
+    public readStateEvents = jest.fn(async () => []);
+    public getTurnServers = jest.fn(async () => []);
+    public sendContentLoaded = jest.fn().mockResolvedValue(undefined);

    public transport = {
        reply: jest.fn(),
@@ -728,10 +727,11 @@ describe("RoomWidgetClient", () => {
            expect(widgetApi.requestCapabilityToSendToDevice).toHaveBeenCalledWith("org.example.foo");

            const payload = { type: "org.example.foo", hello: "world" };
-            await client.encryptAndSendToDevices(
+            const embeddedClient = client as RoomWidgetClient;
+            await embeddedClient.encryptAndSendToDevices(
                [
-                    { userId: "@alice:example.org", deviceInfo: new DeviceInfo("aliceWeb") },
-                    { userId: "@bob:example.org", deviceInfo: new DeviceInfo("bobDesktop") },
+                    { userId: "@alice:example.org", deviceId: "aliceWeb" },
+                    { userId: "@bob:example.org", deviceId: "bobDesktop" },
                ],
                payload,
            );
@@ -14,9 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { MatrixClient, MatrixEvent, MatrixEventEvent, MatrixScheduler, Room } from "../../src";
+import { MatrixClient, MatrixEvent, MatrixEventEvent, type MatrixScheduler, Room } from "../../src";
 import { eventMapperFor } from "../../src/event-mapper";
-import { IStore } from "../../src/store";
+import { type IStore } from "../../src/store";

 describe("eventMapperFor", function () {
    let rooms: Room[] = [];
@@ -3,7 +3,7 @@ import { mocked } from "jest-mock";
 import * as utils from "../test-utils/test-utils";
 import { Direction, EventTimeline } from "../../src/models/event-timeline";
 import { RoomState } from "../../src/models/room-state";
-import { MatrixClient } from "../../src/matrix";
+import { type MatrixClient } from "../../src/matrix";
 import { Room } from "../../src/models/room";
 import { RoomMember } from "../../src/models/room-member";
 import { EventTimelineSet } from "../../src/models/event-timeline-set";
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { ExtensibleEventType, IPartialEvent } from "../../../src/@types/extensible_events";
+import { type ExtensibleEventType, type IPartialEvent } from "../../../src/@types/extensible_events";
 import { ExtensibleEvent } from "../../../src/extensible_events_v1/ExtensibleEvent";

 class MockEvent extends ExtensibleEvent<any> {
@@ -15,8 +15,8 @@ limitations under the License.
 */

 import {
-    ExtensibleAnyMessageEventContent,
-    IPartialEvent,
+    type ExtensibleAnyMessageEventContent,
+    type IPartialEvent,
    M_HTML,
    M_MESSAGE,
    M_TEXT,
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { PollEndEventContent, M_POLL_END } from "../../../src/@types/polls";
-import { IPartialEvent, REFERENCE_RELATION, M_TEXT } from "../../../src/@types/extensible_events";
+import { type PollEndEventContent, M_POLL_END } from "../../../src/@types/polls";
+import { type IPartialEvent, REFERENCE_RELATION, M_TEXT } from "../../../src/@types/extensible_events";
 import { PollEndEvent } from "../../../src/extensible_events_v1/PollEndEvent";
 import { InvalidEventError } from "../../../src/extensible_events_v1/InvalidEventError";

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

-import { M_TEXT, IPartialEvent, REFERENCE_RELATION } from "../../../src/@types/extensible_events";
+import { M_TEXT, type IPartialEvent, REFERENCE_RELATION } from "../../../src/@types/extensible_events";
 import {
    M_POLL_START,
    M_POLL_KIND_DISCLOSED,
-    PollResponseEventContent,
+    type PollResponseEventContent,
    M_POLL_RESPONSE,
 } from "../../../src/@types/polls";
 import { PollStartEvent } from "../../../src/extensible_events_v1/PollStartEvent";
@@ -14,12 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { M_TEXT, IPartialEvent } from "../../../src/@types/extensible_events";
+import { M_TEXT, type IPartialEvent } from "../../../src/@types/extensible_events";
 import {
    M_POLL_START,
    M_POLL_KIND_DISCLOSED,
-    PollAnswer,
-    PollStartEventContent,
+    type PollAnswer,
+    type PollStartEventContent,
    M_POLL_KIND_UNDISCLOSED,
 } from "../../../src/@types/polls";
 import { PollStartEvent, PollAnswerSubevent } from "../../../src/extensible_events_v1/PollStartEvent";
@@ -15,7 +15,7 @@ limitations under the License.
 */

 import { UNREAD_THREAD_NOTIFICATIONS } from "../../src/@types/sync";
-import { Filter, IFilterDefinition } from "../../src/filter";
+import { Filter, type IFilterDefinition } from "../../src/filter";
 import { mkEvent } from "../test-utils/test-utils";
 import { EventType } from "../../src";

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

-import { Mocked } from "jest-mock";
+import { type Mocked } from "jest-mock";

 import { FetchHttpApi } from "../../../src/http-api/fetch";
 import { TypedEventEmitter } from "../../../src/models/typed-event-emitter";
 import {
    ClientPrefix,
+    ConnectionError,
    HttpApiEvent,
-    HttpApiEventHandlerMap,
+    type HttpApiEventHandlerMap,
    IdentityPrefix,
-    IHttpOpts,
+    type IHttpOpts,
    MatrixError,
    Method,
 } from "../../../src";
 import { emitPromise } from "../../test-utils/test-utils";
-import { defer, QueryDict } from "../../../src/utils";
-import { Logger } from "../../../src/logger";
+import { defer, type QueryDict } from "../../../src/utils";
+import { type Logger } from "../../../src/logger";

 describe("FetchHttpApi", () => {
    const baseUrl = "http://baseUrl";
@@ -125,7 +126,7 @@ describe("FetchHttpApi", () => {
        ).resolves.toBe(text);
    });

-    it("should send token via query params if useAuthorizationHeader=false", () => {
+    it("should send token via query params if useAuthorizationHeader=false", async () => {
        const fetchFn = jest.fn().mockResolvedValue({ ok: true });
        const api = new FetchHttpApi(new TypedEventEmitter<any, any>(), {
            baseUrl,
@@ -134,11 +135,11 @@ describe("FetchHttpApi", () => {
            accessToken: "token",
            useAuthorizationHeader: false,
        });
-        api.authedRequest(Method.Get, "/path");
+        await api.authedRequest(Method.Get, "/path");
        expect(fetchFn.mock.calls[0][0].searchParams.get("access_token")).toBe("token");
    });

-    it("should send token via headers by default", () => {
+    it("should send token via headers by default", async () => {
        const fetchFn = jest.fn().mockResolvedValue({ ok: true });
        const api = new FetchHttpApi(new TypedEventEmitter<any, any>(), {
            baseUrl,
@@ -146,7 +147,7 @@ describe("FetchHttpApi", () => {
            fetchFn,
            accessToken: "token",
        });
-        api.authedRequest(Method.Get, "/path");
+        await api.authedRequest(Method.Get, "/path");
        expect(fetchFn.mock.calls[0][1].headers["Authorization"]).toBe("Bearer token");
    });

@@ -163,7 +164,7 @@ describe("FetchHttpApi", () => {
        expect(fetchFn.mock.calls[0][1].headers["Authorization"]).toBeFalsy();
    });

-    it("should ensure no token is leaked out via query params if sending via headers", () => {
+    it("should ensure no token is leaked out via query params if sending via headers", async () => {
        const fetchFn = jest.fn().mockResolvedValue({ ok: true });
        const api = new FetchHttpApi(new TypedEventEmitter<any, any>(), {
            baseUrl,
@@ -172,12 +173,12 @@ describe("FetchHttpApi", () => {
            accessToken: "token",
            useAuthorizationHeader: true,
        });
-        api.authedRequest(Method.Get, "/path", { access_token: "123" });
+        await api.authedRequest(Method.Get, "/path", { access_token: "123" });
        expect(fetchFn.mock.calls[0][0].searchParams.get("access_token")).toBeFalsy();
        expect(fetchFn.mock.calls[0][1].headers["Authorization"]).toBe("Bearer token");
    });

-    it("should not override manually specified access token via query params", () => {
+    it("should not override manually specified access token via query params", async () => {
        const fetchFn = jest.fn().mockResolvedValue({ ok: true });
        const api = new FetchHttpApi(new TypedEventEmitter<any, any>(), {
            baseUrl,
@@ -186,11 +187,11 @@ describe("FetchHttpApi", () => {
            accessToken: "token",
            useAuthorizationHeader: false,
        });
-        api.authedRequest(Method.Get, "/path", { access_token: "RealToken" });
+        await api.authedRequest(Method.Get, "/path", { access_token: "RealToken" });
        expect(fetchFn.mock.calls[0][0].searchParams.get("access_token")).toBe("RealToken");
    });

-    it("should not override manually specified access token via header", () => {
+    it("should not override manually specified access token via header", async () => {
        const fetchFn = jest.fn().mockResolvedValue({ ok: true });
        const api = new FetchHttpApi(new TypedEventEmitter<any, any>(), {
            baseUrl,
@@ -199,16 +200,16 @@ describe("FetchHttpApi", () => {
            accessToken: "token",
            useAuthorizationHeader: true,
        });
-        api.authedRequest(Method.Get, "/path", undefined, undefined, {
+        await api.authedRequest(Method.Get, "/path", undefined, undefined, {
            headers: { Authorization: "Bearer RealToken" },
        });
        expect(fetchFn.mock.calls[0][1].headers["Authorization"]).toBe("Bearer RealToken");
    });

-    it("should not override Accept header", () => {
+    it("should not override Accept header", async () => {
        const fetchFn = jest.fn().mockResolvedValue({ ok: true });
        const api = new FetchHttpApi(new TypedEventEmitter<any, any>(), { baseUrl, prefix, fetchFn });
-        api.authedRequest(Method.Get, "/path", undefined, undefined, {
+        await api.authedRequest(Method.Get, "/path", undefined, undefined, {
            headers: { Accept: "text/html" },
        });
        expect(fetchFn.mock.calls[0][1].headers["Accept"]).toBe("text/html");
@@ -288,7 +289,7 @@ describe("FetchHttpApi", () => {

                describe("with a tokenRefreshFunction", () => {
                    it("should emit logout and throw when token refresh fails", async () => {
-                        const error = new Error("uh oh");
+                        const error = new MatrixError();
                        const tokenRefreshFunction = jest.fn().mockRejectedValue(error);
                        const fetchFn = jest.fn().mockResolvedValue(unknownTokenResponse);
                        const emitter = new TypedEventEmitter<HttpApiEvent, HttpApiEventHandlerMap>();
@@ -308,6 +309,27 @@ describe("FetchHttpApi", () => {
                        expect(emitter.emit).toHaveBeenCalledWith(HttpApiEvent.SessionLoggedOut, unknownTokenErr);
                    });

+                    it("should not emit logout but still throw when token refresh fails due to transitive fault", async () => {
+                        const error = new ConnectionError("transitive fault");
+                        const tokenRefreshFunction = jest.fn().mockRejectedValue(error);
+                        const fetchFn = jest.fn().mockResolvedValue(unknownTokenResponse);
+                        const emitter = new TypedEventEmitter<HttpApiEvent, HttpApiEventHandlerMap>();
+                        jest.spyOn(emitter, "emit");
+                        const api = new FetchHttpApi(emitter, {
+                            baseUrl,
+                            prefix,
+                            fetchFn,
+                            tokenRefreshFunction,
+                            accessToken,
+                            refreshToken,
+                        });
+                        await expect(api.authedRequest(Method.Post, "/account/password")).rejects.toThrow(
+                            unknownTokenErr,
+                        );
+                        expect(tokenRefreshFunction).toHaveBeenCalledWith(refreshToken);
+                        expect(emitter.emit).not.toHaveBeenCalledWith(HttpApiEvent.SessionLoggedOut, unknownTokenErr);
+                    });
+
                    it("should refresh token and retry request", async () => {
                        const newAccessToken = "new-access-token";
                        const newRefreshToken = "new-refresh-token";
@@ -468,4 +490,61 @@ describe("FetchHttpApi", () => {
            ]
        `);
    });
+
+    it("should not make multiple concurrent refresh token requests", async () => {
+        const tokenInactiveError = new MatrixError({ errcode: "M_UNKNOWN_TOKEN", error: "Token is not active" }, 401);
+
+        const deferredTokenRefresh = defer<{ accessToken: string; refreshToken: string }>();
+        const fetchFn = jest.fn().mockResolvedValue({
+            ok: false,
+            status: tokenInactiveError.httpStatus,
+            async text() {
+                return JSON.stringify(tokenInactiveError.data);
+            },
+            async json() {
+                return tokenInactiveError.data;
+            },
+            headers: {
+                get: jest.fn().mockReturnValue("application/json"),
+            },
+        });
+        const tokenRefreshFunction = jest.fn().mockReturnValue(deferredTokenRefresh.promise);
+
+        const api = new FetchHttpApi(new TypedEventEmitter<any, any>(), {
+            baseUrl,
+            prefix,
+            fetchFn,
+            doNotAttemptTokenRefresh: false,
+            tokenRefreshFunction,
+            accessToken: "ACCESS_TOKEN",
+            refreshToken: "REFRESH_TOKEN",
+        });
+
+        const prom1 = api.authedRequest(Method.Get, "/path1");
+        const prom2 = api.authedRequest(Method.Get, "/path2");
+
+        await jest.advanceTimersByTimeAsync(10); // wait for requests to fire
+        expect(fetchFn).toHaveBeenCalledTimes(2);
+        fetchFn.mockResolvedValue({
+            ok: true,
+            status: 200,
+            async text() {
+                return "{}";
+            },
+            async json() {
+                return {};
+            },
+            headers: {
+                get: jest.fn().mockReturnValue("application/json"),
+            },
+        });
+        deferredTokenRefresh.resolve({ accessToken: "NEW_ACCESS_TOKEN", refreshToken: "NEW_REFRESH_TOKEN" });
+
+        await prom1;
+        await prom2;
+        expect(fetchFn).toHaveBeenCalledTimes(4); // 2 original calls + 2 retries
+        expect(tokenRefreshFunction).toHaveBeenCalledTimes(1);
+        expect(api.opts.accessToken).toBe("NEW_ACCESS_TOKEN");
+        expect(api.opts.refreshToken).toBe("NEW_REFRESH_TOKEN");
+    });
 });
@@ -16,7 +16,7 @@ limitations under the License.

 import { mocked } from "jest-mock";

-import { ClientPrefix, MatrixHttpApi, Method, UploadResponse } from "../../../src";
+import { ClientPrefix, MatrixHttpApi, Method, type UploadResponse } from "../../../src";
 import { TypedEventEmitter } from "../../../src/models/typed-event-emitter";

 type Writeable<T> = { -readonly [P in keyof T]: T[P] };
@@ -59,11 +59,12 @@ describe("MatrixHttpApi", () => {
        xhr.onreadystatechange?.(new Event("test"));
    });

-    it("should fall back to `fetch` where xhr is unavailable", () => {
+    it("should fall back to `fetch` where xhr is unavailable", async () => {
        globalThis.XMLHttpRequest = undefined!;
        const fetchFn = jest.fn().mockResolvedValue({ ok: true, json: jest.fn().mockResolvedValue({}) });
        const api = new MatrixHttpApi(new TypedEventEmitter<any, any>(), { baseUrl, prefix, fetchFn });
        upload = api.uploadContent({} as File);
+        await upload;
        expect(fetchFn).toHaveBeenCalled();
    });

@@ -15,7 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { MatrixClient } from "../../src/client";
+import { type MatrixClient } from "../../src/client";
 import { logger } from "../../src/logger";
 import { InteractiveAuth, AuthType } from "../../src/interactive-auth";
 import { HTTPError, MatrixError } from "../../src/http-api";
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { LocalNotificationSettings } from "../../src/@types/local_notifications";
-import { LOCAL_NOTIFICATION_SETTINGS_PREFIX, MatrixClient } from "../../src/matrix";
+import { type LocalNotificationSettings } from "../../src/@types/local_notifications";
+import { LOCAL_NOTIFICATION_SETTINGS_PREFIX, type MatrixClient } from "../../src/matrix";
 import { TestClient } from "../TestClient";

 let client: MatrixClient;
@@ -20,7 +20,7 @@ import {
    LocationAssetType,
    M_LOCATION,
    M_TIMESTAMP,
-    LocationEventWireContent,
+    type LocationEventWireContent,
 } from "../../src/@types/location";
 import { M_TEXT } from "../../src/@types/extensible_events";
 import { MsgType } from "../../src/@types/event";
@@ -0,0 +1,51 @@
+/*
+Copyright 2025 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.
+*/
+
+/* eslint-disable no-console */
+
+import loglevel from "loglevel";
+
+import { logger } from "../../src/logger.ts";
+
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+
+describe("logger", () => {
+    it("should log to console by default", () => {
+        jest.spyOn(console, "debug").mockReturnValue(undefined);
+        logger.debug("test1");
+        logger.log("test2");
+
+        expect(console.debug).toHaveBeenCalledWith("test1");
+        expect(console.debug).toHaveBeenCalledWith("test2");
+    });
+
+    it("should allow creation of child loggers which add a prefix", () => {
+        jest.spyOn(loglevel, "getLogger");
+        jest.spyOn(console, "debug").mockReturnValue(undefined);
+
+        const childLogger = logger.getChild("[prefix1]");
+        expect(loglevel.getLogger).toHaveBeenCalledWith("matrix-[prefix1]");
+        childLogger.debug("test1");
+        expect(console.debug).toHaveBeenCalledWith("[prefix1]", "test1");
+
+        const grandchildLogger = childLogger.getChild("[prefix2]");
+        expect(loglevel.getLogger).toHaveBeenCalledWith("matrix-[prefix1][prefix2]");
+        grandchildLogger.debug("test2");
+        expect(console.debug).toHaveBeenCalledWith("[prefix1][prefix2]", "test2");
+    });
+});
@@ -14,11 +14,17 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { Mocked, mocked } from "jest-mock";
+import { type Mocked, mocked } from "jest-mock";
 import fetchMock from "fetch-mock-jest";

 import { logger } from "../../src/logger";
-import { ClientEvent, IMatrixClientCreateOpts, ITurnServerResponse, MatrixClient, Store } from "../../src/client";
+import {
+    ClientEvent,
+    type IMatrixClientCreateOpts,
+    type ITurnServerResponse,
+    MatrixClient,
+    type Store,
+} from "../../src/client";
 import { Filter } from "../../src/filter";
 import { DEFAULT_TREE_POWER_LEVELS_TEMPLATE } from "../../src/models/MSC3089TreeSpace";
 import {
@@ -31,8 +37,6 @@ import {
    UNSTABLE_MSC3088_PURPOSE,
    UNSTABLE_MSC3089_TREE_SUBTYPE,
 } from "../../src/@types/event";
-import { MEGOLM_ALGORITHM } from "../../src/crypto/olmlib";
-import { Crypto } from "../../src/crypto";
 import { EventStatus, MatrixEvent } from "../../src/models/event";
 import { Preset } from "../../src/@types/partials";
 import { ReceiptType } from "../../src/@types/read_receipts";
@@ -43,16 +47,17 @@ import {
    ClientPrefix,
    ConditionKind,
    ContentHelpers,
+    createClient,
    Direction,
    EventTimeline,
    EventTimelineSet,
    getHttpUriForMxc,
-    ICreateRoomOpts,
-    IPushRule,
-    IRequestOpts,
+    type ICreateRoomOpts,
+    type IPushRule,
+    type IRequestOpts,
    MatrixError,
-    MatrixHttpApi,
-    MatrixScheduler,
+    type MatrixHttpApi,
+    type MatrixScheduler,
    Method,
    PushRuleActionName,
    Room,
@@ -68,16 +73,17 @@ import {
    PolicyRecommendation,
    PolicyScope,
 } from "../../src/models/invites-ignorer";
-import { IOlmDevice } from "../../src/crypto/algorithms/megolm";
-import { defer, QueryDict } from "../../src/utils";
-import { SyncState } from "../../src/sync";
+import { defer, type QueryDict } from "../../src/utils";
+import { type SyncState } from "../../src/sync";
 import * as featureUtils from "../../src/feature";
 import { StubStore } from "../../src/store/stub";
-import { SecretStorageKeyDescriptionAesV1, ServerSideSecretStorageImpl } from "../../src/secret-storage";
-import { CryptoBackend } from "../../src/common-crypto/CryptoBackend";
+import { type ServerSideSecretStorageImpl } from "../../src/secret-storage";
 import { KnownMembership } from "../../src/@types/membership";
-import { RoomMessageEventContent } from "../../src/@types/events";
+import { type RoomMessageEventContent } from "../../src/@types/events";
 import { mockOpenIdConfiguration } from "../test-utils/oidc.ts";
+import { type CryptoBackend } from "../../src/common-crypto/CryptoBackend";
+import { SyncResponder } from "../test-utils/SyncResponder.ts";
+import { mockInitialApiRequests } from "../test-utils/mockEndpoints.ts";

 jest.useFakeTimers();

@@ -122,6 +128,18 @@ type WrappedRoom = Room & {
    _state: Map<string, any>;
 };

+/** A list of methods to run after the current test */
+const afterTestHooks: (() => Promise<void> | void)[] = [];
+
+afterEach(async () => {
+    fetchMock.reset();
+    jest.restoreAllMocks();
+    for (const hook of afterTestHooks) {
+        await hook();
+    }
+    afterTestHooks.length = 0;
+});
+
 describe("convertQueryDictToMap", () => {
    it("returns an empty map when dict is undefined", () => {
        expect(convertQueryDictToMap(undefined)).toEqual(new Map());
@@ -162,6 +180,11 @@ describe("MatrixClient", function () {
    const userId = "@alice:bar";
    const identityServerUrl = "https://identity.server";
    const identityServerDomain = "identity.server";
+
+    /**
+     * @deprecated this is hard to use correctly; better to create a regular client with {@link createClient}
+     * and use fetch-mock.
+     */
    let client: MatrixClient;
    let store: Store;
    let scheduler: MatrixScheduler;
@@ -584,6 +607,26 @@ describe("MatrixClient", function () {
        });
    });

+    describe("reportRoom", function () {
+        const roomId = "!foo:bar";
+        const reason = "rubbish room";
+
+        it("should send an invite HTTP POST", async function () {
+            httpLookups = [
+                {
+                    method: "POST",
+                    path: "/rooms/!foo%3Abar/report",
+                    data: {},
+                    expectBody: {
+                        reason,
+                    },
+                },
+            ];
+            await client.reportRoom(roomId, reason);
+            expect(httpLookups.length).toEqual(0);
+        });
+    });
+
    describe("sendEvent", () => {
        const roomId = "!room:example.org";
        const body = "This is the body";
@@ -1190,7 +1233,7 @@ describe("MatrixClient", function () {
                        type: EventType.RoomEncryption,
                        state_key: "",
                        content: {
-                            algorithm: MEGOLM_ALGORITHM,
+                            algorithm: "m.megolm.v1.aes-sha2",
                        },
                    },
                ],
@@ -1916,7 +1959,7 @@ describe("MatrixClient", function () {
            hasEncryptionStateEvent: jest.fn().mockReturnValue(true),
        } as unknown as Room;

-        let mockCrypto: Mocked<Crypto>;
+        let mockCrypto: Mocked<CryptoBackend>;

        let event: MatrixEvent;
        beforeEach(async () => {
@@ -1936,8 +1979,8 @@ describe("MatrixClient", function () {
                isEncryptionEnabledInRoom: jest.fn().mockResolvedValue(true),
                encryptEvent: jest.fn(),
                stop: jest.fn(),
-            } as unknown as Mocked<Crypto>;
-            client.crypto = client["cryptoBackend"] = mockCrypto;
+            } as unknown as Mocked<CryptoBackend>;
+            client["cryptoBackend"] = mockCrypto;
        });

        function assertCancelled() {
@@ -2256,7 +2299,7 @@ describe("MatrixClient", function () {
    });

    describe("checkTurnServers", () => {
-        beforeAll(() => {
+        beforeEach(() => {
            mocked(supportsMatrixCall).mockReturnValue(true);
        });

@@ -2323,21 +2366,6 @@ describe("MatrixClient", function () {
        });
    });

-    describe("encryptAndSendToDevices", () => {
-        it("throws an error if crypto is unavailable", () => {
-            client.crypto = undefined;
-            expect(() => client.encryptAndSendToDevices([], {})).toThrow();
-        });
-
-        it("is an alias for the crypto method", async () => {
-            client.crypto = testUtils.mock(Crypto, "Crypto");
-            const deviceInfos: IOlmDevice[] = [];
-            const payload = {};
-            await client.encryptAndSendToDevices(deviceInfos, payload);
-            expect(client.crypto.encryptAndSendToDevices).toHaveBeenLastCalledWith(deviceInfos, payload);
-        });
-    });
-
    describe("support for ignoring invites", () => {
        beforeEach(() => {
            // Mockup `getAccountData`/`setAccountData`.
@@ -2671,10 +2699,165 @@ describe("MatrixClient", function () {
        });
    });

-    describe("delete account data", () => {
-        afterEach(() => {
-            jest.spyOn(featureUtils, "buildFeatureSupportMap").mockRestore();
+    describe("setAccountData", () => {
+        const TEST_HOMESERVER_URL = "https://alice-server.com";
+
+        /** Create and start a MatrixClient, connected to the `TEST_HOMESERVER_URL` */
+        async function setUpClient(): Promise<MatrixClient> {
+            // anything that we don't have a specific matcher for silently returns a 404
+            fetchMock.catch(404);
+            fetchMock.config.warnOnFallback = false;
+
+            mockInitialApiRequests(TEST_HOMESERVER_URL, userId);
+
+            const client = createClient({ baseUrl: TEST_HOMESERVER_URL, userId });
+            await client.startClient();
+
+            // Remember to stop the client again, to stop it spamming logs and HTTP requests
+            afterTestHooks.push(() => client.stopClient());
+            return client;
+        }
+
+        it("falls back to raw request if called before the client is started", async () => {
+            // GIVEN a bunch of setup
+            const client = createClient({ baseUrl: TEST_HOMESERVER_URL, userId });
+
+            const eventType = "im.vector.test";
+            const content = { a: 1 };
+            const testresponse = { test: 1 };
+
+            // ... including an expected REST request
+            const url = new URL(
+                `/_matrix/client/v3/user/${encodeURIComponent(client.getSafeUserId())}/account_data/${eventType}`,
+                TEST_HOMESERVER_URL,
+            ).toString();
+            fetchMock.put({ url, name: "put-account-data" }, testresponse);
+
+            // suppress the expected warning on the console
+            jest.spyOn(console, "warn").mockImplementation();
+
+            // WHEN we call `setAccountData` ...
+            const result = await client.setAccountData(eventType, content);
+
+            // THEN, method should have returned the right thing
+            expect(result).toEqual(testresponse);
+
+            // and the REST call should have happened, and had the correct content
+            const lastCall = fetchMock.lastCall("put-account-data");
+            expect(lastCall).toBeDefined();
+            expect(lastCall?.[1]?.body).toEqual(JSON.stringify(content));
+
+            // and a warning should have been logged
+            // eslint-disable-next-line no-console
+            expect(console.warn).toHaveBeenCalledWith(
+                expect.stringContaining("Calling `setAccountData` before the client is started"),
+            );
        });
+
+        it("makes a request to the server, and waits for the /sync response", async () => {
+            // GIVEN a bunch of setup
+            const syncResponder = new SyncResponder(TEST_HOMESERVER_URL);
+            const client = await setUpClient();
+
+            const eventType = "im.vector.test";
+            const content = { a: 1 };
+            const testresponse = { test: 1 };
+
+            // ... including an expected REST request
+            const url = new URL(
+                `/_matrix/client/v3/user/${encodeURIComponent(client.getSafeUserId())}/account_data/${eventType}`,
+                TEST_HOMESERVER_URL,
+            ).toString();
+            fetchMock.put({ url, name: "put-account-data" }, testresponse);
+
+            // WHEN we call `setAccountData` ...
+            const setProm = client.setAccountData(eventType, content);
+
+            await jest.advanceTimersByTimeAsync(10);
+            // THEN, the REST call should have happened, and had the correct content
+            const lastCall = fetchMock.lastCall("put-account-data");
+            expect(lastCall).toBeDefined();
+            expect(lastCall?.[1]?.body).toEqual(JSON.stringify(content));
+
+            // Even after waiting a bit more, the method should not yet have returned
+            await jest.advanceTimersByTimeAsync(10);
+            let finished = false;
+            setProm.finally(() => (finished = true));
+            expect(finished).toBeFalsy();
+
+            // ... and `getAccountData` still returns the wrong thing
+            expect(client.getAccountData(eventType)).not.toBeDefined();
+
+            // WHEN the update arrives over /sync
+            const content2 = { a: 2 };
+
+            syncResponder.sendOrQueueSyncResponse({
+                account_data: { events: [{ type: eventType, content: content2 }] },
+            });
+
+            // THEN the method should complete, and `getAccountData` returns the new data
+            expect(await setProm).toEqual(testresponse);
+            expect(client.getAccountData(eventType)?.event).toEqual({ type: eventType, content: content2 });
+        });
+
+        it("does nothing if the data matches what is there", async () => {
+            // GIVEN a running matrix client ...
+            const syncResponder = new SyncResponder(TEST_HOMESERVER_URL);
+            const client = await setUpClient();
+
+            // ... which has previously received the account data over /sync
+            const eventType = "im.vector.test";
+            const content = { a: 1, b: 2 };
+
+            // Keys in a different order, to check that doesn't matter.
+            const syncedContent = { b: 2, a: 1 };
+            syncResponder.sendOrQueueSyncResponse({
+                account_data: { events: [{ type: eventType, content: syncedContent }] },
+            });
+            await jest.advanceTimersByTimeAsync(1);
+
+            // Check that getAccountData is ready
+            expect(client.getAccountData(eventType)?.event).toEqual({ type: eventType, content: syncedContent });
+
+            // WHEN we call `setAccountData` ...
+            await client.setAccountData(eventType, content);
+
+            // THEN there should be no REST call
+            expect(fetchMock.calls(/account_data/).length).toEqual(0);
+        });
+    });
+
+    describe("delete account data", () => {
+        const TEST_HOMESERVER_URL = "https://alice-server.com";
+
+        /** Create and start a MatrixClient, connected to the `TEST_HOMESERVER_URL` */
+        async function setUpClient(versionsResponse: object = { versions: ["1"] }): Promise<MatrixClient> {
+            // anything that we don't have a specific matcher for silently returns a 404
+            fetchMock.catch(404);
+            fetchMock.config.warnOnFallback = false;
+
+            fetchMock.getOnce(new URL("/_matrix/client/versions", TEST_HOMESERVER_URL).toString(), versionsResponse, {
+                overwriteRoutes: true,
+            });
+            fetchMock.getOnce(
+                new URL("/_matrix/client/v3/pushrules/", TEST_HOMESERVER_URL).toString(),
+                {},
+                { overwriteRoutes: true },
+            );
+            fetchMock.postOnce(
+                new URL(`/_matrix/client/v3/user/${encodeURIComponent(userId)}/filter`, TEST_HOMESERVER_URL).toString(),
+                { filter_id: "fid" },
+                { overwriteRoutes: true },
+            );
+
+            const client = createClient({ baseUrl: TEST_HOMESERVER_URL, userId });
+            await client.startClient();
+
+            // Remember to stop the client again, to stop it spamming logs and HTTP requests
+            afterTestHooks.push(() => client.stopClient());
+            return client;
+        }
+
        it("makes correct request when deletion is supported by server in unstable versions", async () => {
            const eventType = "im.vector.test";
            const versionsResponse = {
@@ -2683,17 +2866,17 @@ describe("MatrixClient", function () {
                    "org.matrix.msc3391": true,
                },
            };
-            const requestSpy = jest.spyOn(client.http, "authedRequest").mockResolvedValue(versionsResponse);
-            const unstablePrefix = "/_matrix/client/unstable/org.matrix.msc3391";
-            const path = `/user/${encodeURIComponent(userId)}/account_data/${eventType}`;
+            const client = await setUpClient(versionsResponse);
+
+            const url = new URL(
+                `/_matrix/client/unstable/org.matrix.msc3391/user/${encodeURIComponent(userId)}/account_data/${eventType}`,
+                TEST_HOMESERVER_URL,
+            ).toString();
+            fetchMock.delete({ url, name: "delete-data" }, {});

-            // populate version support
-            await client.getVersions();
            await client.deleteAccountData(eventType);

-            expect(requestSpy).toHaveBeenCalledWith(Method.Delete, path, undefined, undefined, {
-                prefix: unstablePrefix,
-            });
+            expect(fetchMock.calls("delete-data").length).toEqual(1);
        });

        it("makes correct request when deletion is supported by server based on matrix version", async () => {
@@ -2702,34 +2885,43 @@ describe("MatrixClient", function () {
            // so mock the support map to fake stable support
            const stableSupportedDeletionMap = new Map();
            stableSupportedDeletionMap.set(featureUtils.Feature.AccountDataDeletion, featureUtils.ServerSupport.Stable);
-            jest.spyOn(featureUtils, "buildFeatureSupportMap").mockResolvedValue(new Map());
-            const requestSpy = jest.spyOn(client.http, "authedRequest").mockImplementation(() => Promise.resolve());
-            const path = `/user/${encodeURIComponent(userId)}/account_data/${eventType}`;
+            jest.spyOn(featureUtils, "buildFeatureSupportMap").mockResolvedValue(stableSupportedDeletionMap);
+
+            const client = await setUpClient();
+
+            const url = new URL(
+                `/_matrix/client/v3/user/${encodeURIComponent(userId)}/account_data/${eventType}`,
+                TEST_HOMESERVER_URL,
+            ).toString();
+            fetchMock.delete({ url, name: "delete-data" }, {});

-            // populate version support
-            await client.getVersions();
            await client.deleteAccountData(eventType);

-            expect(requestSpy).toHaveBeenCalledWith(Method.Delete, path, undefined, undefined, undefined);
+            expect(fetchMock.calls("delete-data").length).toEqual(1);
        });

        it("makes correct request when deletion is not supported by server", async () => {
            const eventType = "im.vector.test";
-            const versionsResponse = {
-                versions: ["1"],
-                unstable_features: {
-                    "org.matrix.msc3391": false,
-                },
-            };
-            const requestSpy = jest.spyOn(client.http, "authedRequest").mockResolvedValue(versionsResponse);
-            const path = `/user/${encodeURIComponent(userId)}/account_data/${eventType}`;

-            // populate version support
-            await client.getVersions();
-            await client.deleteAccountData(eventType);
+            const syncResponder = new SyncResponder(TEST_HOMESERVER_URL);
+            const client = await setUpClient();
+
+            const url = new URL(
+                `/_matrix/client/v3/user/${encodeURIComponent(userId)}/account_data/${eventType}`,
+                TEST_HOMESERVER_URL,
+            ).toString();
+            fetchMock.put({ url, name: "put-account-data" }, {});
+
+            const setProm = client.deleteAccountData(eventType);
+            syncResponder.sendOrQueueSyncResponse({
+                account_data: { events: [{ type: eventType, content: {} }] },
+            });
+            await setProm;

            // account data updated with empty content
-            expect(requestSpy).toHaveBeenCalledWith(Method.Put, path, undefined, {});
+            const lastCall = fetchMock.lastCall("put-account-data");
+            expect(lastCall).toBeDefined();
+            expect(lastCall?.[1]?.body).toEqual("{}");
        });
    });

@@ -3199,24 +3391,6 @@ describe("MatrixClient", function () {
            client["_secretStorage"] = mockSecretStorage;
        });

-        it("hasSecretStorageKey", async () => {
-            mockSecretStorage.hasKey.mockResolvedValue(false);
-            expect(await client.hasSecretStorageKey("mykey")).toBe(false);
-            expect(mockSecretStorage.hasKey).toHaveBeenCalledWith("mykey");
-        });
-
-        it("isSecretStored", async () => {
-            const mockResult = { key: {} as SecretStorageKeyDescriptionAesV1 };
-            mockSecretStorage.isStored.mockResolvedValue(mockResult);
-            expect(await client.isSecretStored("mysecret")).toBe(mockResult);
-            expect(mockSecretStorage.isStored).toHaveBeenCalledWith("mysecret");
-        });
-
-        it("getDefaultSecretStorageKeyId", async () => {
-            mockSecretStorage.getDefaultKeyId.mockResolvedValue("bzz");
-            expect(await client.getDefaultSecretStorageKeyId()).toEqual("bzz");
-        });
-
        it("isKeyBackupKeyStored", async () => {
            mockSecretStorage.isStored.mockResolvedValue(null);
            expect(await client.isKeyBackupKeyStored()).toBe(null);
@@ -3224,60 +3398,6 @@ describe("MatrixClient", function () {
        });
    });

-    // these wrappers are deprecated, but we need coverage of them to pass the quality gate
-    describe("Crypto wrappers", () => {
-        describe("exception if no crypto", () => {
-            it("isCrossSigningReady", () => {
-                expect(() => client.isCrossSigningReady()).toThrow("End-to-end encryption disabled");
-            });
-
-            it("bootstrapCrossSigning", () => {
-                expect(() => client.bootstrapCrossSigning({})).toThrow("End-to-end encryption disabled");
-            });
-
-            it("isSecretStorageReady", () => {
-                expect(() => client.isSecretStorageReady()).toThrow("End-to-end encryption disabled");
-            });
-        });
-
-        describe("defer to crypto backend", () => {
-            let mockCryptoBackend: Mocked<CryptoBackend>;
-
-            beforeEach(() => {
-                mockCryptoBackend = {
-                    isCrossSigningReady: jest.fn(),
-                    bootstrapCrossSigning: jest.fn(),
-                    isSecretStorageReady: jest.fn(),
-                    stop: jest.fn().mockResolvedValue(undefined),
-                } as unknown as Mocked<CryptoBackend>;
-                client["cryptoBackend"] = mockCryptoBackend;
-            });
-
-            it("isCrossSigningReady", async () => {
-                const testResult = "test";
-                mockCryptoBackend.isCrossSigningReady.mockResolvedValue(testResult as unknown as boolean);
-                expect(await client.isCrossSigningReady()).toBe(testResult);
-                expect(mockCryptoBackend.isCrossSigningReady).toHaveBeenCalledTimes(1);
-            });
-
-            it("bootstrapCrossSigning", async () => {
-                const testOpts = {};
-                mockCryptoBackend.bootstrapCrossSigning.mockResolvedValue(undefined);
-                await client.bootstrapCrossSigning(testOpts);
-                expect(mockCryptoBackend.bootstrapCrossSigning).toHaveBeenCalledTimes(1);
-                expect(mockCryptoBackend.bootstrapCrossSigning).toHaveBeenCalledWith(testOpts);
-            });
-
-            it("isSecretStorageReady", async () => {
-                client["cryptoBackend"] = mockCryptoBackend;
-                const testResult = "test";
-                mockCryptoBackend.isSecretStorageReady.mockResolvedValue(testResult as unknown as boolean);
-                expect(await client.isSecretStorageReady()).toBe(testResult);
-                expect(mockCryptoBackend.isSecretStorageReady).toHaveBeenCalledTimes(1);
-            });
-        });
-    });
-
    describe("paginateEventTimeline()", () => {
        describe("notifications timeline", () => {
            const unsafeNotification = {
@@ -14,8 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { MatrixEvent } from "../../../src";
-import { CallMembership, SessionMembershipData, DEFAULT_EXPIRE_DURATION } from "../../../src/matrixrtc/CallMembership";
+import { type MatrixEvent } from "../../../src";
+import {
+    CallMembership,
+    type SessionMembershipData,
+    DEFAULT_EXPIRE_DURATION,
+} from "../../../src/matrixrtc/CallMembership";
 import { membershipTemplate } from "./mocks";

 function makeMockEvent(originTs = 0): MatrixEvent {
@@ -14,13 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { encodeBase64, EventType, MatrixClient, MatrixError, MatrixEvent, Room } from "../../../src";
+import { encodeBase64, EventType, MatrixClient, type MatrixError, type MatrixEvent, type Room } from "../../../src";
 import { KnownMembership } from "../../../src/@types/membership";
-import { DEFAULT_EXPIRE_DURATION, SessionMembershipData } from "../../../src/matrixrtc/CallMembership";
+import { DEFAULT_EXPIRE_DURATION, type SessionMembershipData } from "../../../src/matrixrtc/CallMembership";
 import { MatrixRTCSession, MatrixRTCSessionEvent } from "../../../src/matrixrtc/MatrixRTCSession";
-import { EncryptionKeysEventContent } from "../../../src/matrixrtc/types";
+import { type EncryptionKeysEventContent } from "../../../src/matrixrtc/types";
 import { secureRandomString } from "../../../src/randomstring";
-import { flushPromises } from "../../test-utils/flushPromises";
 import { makeMockRoom, makeMockRoomState, membershipTemplate } from "./mocks";

 const mockFocus = { type: "mock" };
@@ -37,10 +36,10 @@ describe("MatrixRTCSession", () => {
        client.getDeviceId = jest.fn().mockReturnValue("AAAAAAA");
    });

-    afterEach(() => {
+    afterEach(async () => {
        client.stopClient();
        client.matrixRTC.stop();
-        if (sess) sess.stop();
+        if (sess) await sess.stop();
        sess = undefined;
    });

@@ -322,11 +321,9 @@ describe("MatrixRTCSession", () => {
        let sendStateEventMock: jest.Mock;
        let sendDelayedStateMock: jest.Mock;
        let sendEventMock: jest.Mock;
-        let updateDelayedEventMock: jest.Mock;

        let sentStateEvent: Promise<void>;
        let sentDelayedState: Promise<void>;
-        let updatedDelayedEvent: Promise<void>;

        beforeEach(() => {
            sentStateEvent = new Promise((resolve) => {
@@ -340,15 +337,12 @@ describe("MatrixRTCSession", () => {
                    };
                });
            });
-            updatedDelayedEvent = new Promise((r) => {
-                updateDelayedEventMock = jest.fn(r);
-            });
            sendEventMock = jest.fn();
            client.sendStateEvent = sendStateEventMock;
            client._unstable_sendDelayedStateEvent = sendDelayedStateMock;
            client.sendEvent = sendEventMock;

-            client._unstable_updateDelayedEvent = updateDelayedEventMock;
+            client._unstable_updateDelayedEvent = jest.fn();

            mockRoom = makeMockRoom([]);
            sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
@@ -432,120 +426,6 @@ describe("MatrixRTCSession", () => {
            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
            jest.useRealTimers();
        });
-
-        describe("calls", () => {
-            const activeFocusConfig = { type: "livekit", livekit_service_url: "https://active.url" };
-            const activeFocus = { type: "livekit", focus_selection: "oldest_membership" };
-
-            async function testJoin(useOwnedStateEvents: boolean): Promise<void> {
-                if (useOwnedStateEvents) {
-                    mockRoom.getVersion = jest.fn().mockReturnValue("org.matrix.msc3757.default");
-                }
-
-                jest.useFakeTimers();
-
-                // preparing the delayed disconnect should handle the delay being too long
-                const sendDelayedStateExceedAttempt = new Promise<void>((resolve) => {
-                    const error = new MatrixError({
-                        "errcode": "M_UNKNOWN",
-                        "org.matrix.msc4140.errcode": "M_MAX_DELAY_EXCEEDED",
-                        "org.matrix.msc4140.max_delay": 7500,
-                    });
-                    sendDelayedStateMock.mockImplementationOnce(() => {
-                        resolve();
-                        return Promise.reject(error);
-                    });
-                });
-
-                const userStateKey = `${!useOwnedStateEvents ? "_" : ""}@alice:example.org_AAAAAAA`;
-                // preparing the delayed disconnect should handle ratelimiting
-                const sendDelayedStateAttempt = new Promise<void>((resolve) => {
-                    const error = new MatrixError({ errcode: "M_LIMIT_EXCEEDED" });
-                    sendDelayedStateMock.mockImplementationOnce(() => {
-                        resolve();
-                        return Promise.reject(error);
-                    });
-                });
-
-                // setting the membership state should handle ratelimiting (also with a retry-after value)
-                const sendStateEventAttempt = new Promise<void>((resolve) => {
-                    const error = new MatrixError(
-                        { errcode: "M_LIMIT_EXCEEDED" },
-                        429,
-                        undefined,
-                        undefined,
-                        new Headers({ "Retry-After": "1" }),
-                    );
-                    sendStateEventMock.mockImplementationOnce(() => {
-                        resolve();
-                        return Promise.reject(error);
-                    });
-                });
-
-                sess!.joinRoomSession([activeFocusConfig], activeFocus, {
-                    membershipServerSideExpiryTimeout: 9000,
-                });
-
-                await sendDelayedStateExceedAttempt.then(); // needed to resolve after the send attempt catches
-                await sendDelayedStateAttempt;
-                const callProps = (d: number) => {
-                    return [mockRoom!.roomId, { delay: d }, "org.matrix.msc3401.call.member", {}, userStateKey];
-                };
-                expect(client._unstable_sendDelayedStateEvent).toHaveBeenNthCalledWith(1, ...callProps(9000));
-                expect(client._unstable_sendDelayedStateEvent).toHaveBeenNthCalledWith(2, ...callProps(7500));
-
-                jest.advanceTimersByTime(5000);
-
-                await sendStateEventAttempt.then(); // needed to resolve after resendIfRateLimited catches
-                jest.advanceTimersByTime(1000);
-
-                await sentStateEvent;
-                expect(client.sendStateEvent).toHaveBeenCalledWith(
-                    mockRoom!.roomId,
-                    EventType.GroupCallMemberPrefix,
-                    {
-                        application: "m.call",
-                        scope: "m.room",
-                        call_id: "",
-                        expires: 14400000,
-                        device_id: "AAAAAAA",
-                        foci_preferred: [activeFocusConfig],
-                        focus_active: activeFocus,
-                    } satisfies SessionMembershipData,
-                    userStateKey,
-                );
-                await sentDelayedState;
-
-                // should have prepared the heartbeat to keep delaying the leave event while still connected
-                await updatedDelayedEvent;
-                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
-
-                // ensures that we reach the code that schedules the timeout for the next delay update before we advance the timers.
-                await flushPromises();
-                jest.advanceTimersByTime(5000);
-                // should update delayed disconnect
-                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(2);
-
-                jest.useRealTimers();
-            }
-
-            it("sends a membership event with session payload when joining a call", async () => {
-                await testJoin(false);
-            });
-
-            it("does not prefix the state key with _ for rooms that support user-owned state events", async () => {
-                await testJoin(true);
-            });
-        });
-
-        it("does nothing if join called when already joined", async () => {
-            sess!.joinRoomSession([mockFocus], mockFocus);
-            await sentStateEvent;
-            expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
-
-            sess!.joinRoomSession([mockFocus], mockFocus);
-            expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
-        });
    });

    describe("onMembershipsChanged", () => {
@@ -616,9 +496,9 @@ describe("MatrixRTCSession", () => {
                sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
            });

-            afterEach(() => {
+            afterEach(async () => {
                // stop the timers
-                sess!.leaveRoomSession();
+                await sess!.leaveRoomSession();
            });

            it("creates a key when joining", () => {
@@ -715,7 +595,7 @@ describe("MatrixRTCSession", () => {
                }
            });

-            it("cancels key send event that fail", async () => {
+            it("cancels key send event that fail", () => {
                const eventSentinel = {} as unknown as MatrixEvent;

                client.cancelPendingEvent = jest.fn();
@@ -14,15 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { Mock } from "jest-mock";
+import { type Mock } from "jest-mock";

 import {
    ClientEvent,
    EventTimeline,
    EventType,
-    IRoomTimelineData,
+    type IRoomTimelineData,
    MatrixClient,
-    MatrixEvent,
+    type MatrixEvent,
    RoomEvent,
 } from "../../../src";
 import { RoomStateEvent } from "../../../src/models/room-state";
@@ -32,7 +32,7 @@ import { makeMockRoom, makeMockRoomState, membershipTemplate } from "./mocks";
 describe("MatrixRTCSessionManager", () => {
    let client: MatrixClient;

-    beforeEach(async () => {
+    beforeEach(() => {
        client = new MatrixClient({ baseUrl: "base_url" });
        client.matrixRTC.start();
    });
@@ -0,0 +1,765 @@
+/**
+ * @jest-environment ./spec/unit/matrixrtc/memberManagerTestEnvironment.ts
+ */
+/*
+Copyright 2025 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { type MockedFunction, type Mock } from "jest-mock";
+
+import { EventType, HTTPError, MatrixError, UnsupportedDelayedEventsEndpointError, type Room } from "../../../src";
+import {
+    MembershipManagerEvent,
+    Status,
+    type Focus,
+    type LivekitFocusActive,
+    type SessionMembershipData,
+} from "../../../src/matrixrtc";
+import { LegacyMembershipManager } from "../../../src/matrixrtc/LegacyMembershipManager";
+import { makeMockClient, makeMockRoom, membershipTemplate, mockCallMembership, type MockClient } from "./mocks";
+import { MembershipManager } from "../../../src/matrixrtc/NewMembershipManager";
+import { defer } from "../../../src/utils";
+
+function waitForMockCall(method: MockedFunction<any>, returnVal?: Promise<any>) {
+    return new Promise<void>((resolve) => {
+        method.mockImplementation(() => {
+            resolve();
+            return returnVal ?? Promise.resolve();
+        });
+    });
+}
+function waitForMockCallOnce(method: MockedFunction<any>, returnVal?: Promise<any>) {
+    return new Promise<void>((resolve) => {
+        method.mockImplementationOnce(() => {
+            resolve();
+            return returnVal ?? Promise.resolve();
+        });
+    });
+}
+
+function createAsyncHandle(method: MockedFunction<any>) {
+    const { reject, resolve, promise } = defer();
+    method.mockImplementation(() => promise);
+    return { reject, resolve };
+}
+
+/**
+ * Tests different MembershipManager implementations. Some tests don't apply to `LegacyMembershipManager`
+ * use !FailsForLegacy to skip those. See: testEnvironment for more details.
+ */
+
+describe.each([
+    { TestMembershipManager: LegacyMembershipManager, description: "LegacyMembershipManager" },
+    { TestMembershipManager: MembershipManager, description: "MembershipManager" },
+])("$description", ({ TestMembershipManager }) => {
+    let client: MockClient;
+    let room: Room;
+    const focusActive: LivekitFocusActive = {
+        focus_selection: "oldest_membership",
+        type: "livekit",
+    };
+    const focus: Focus = {
+        type: "livekit",
+        livekit_service_url: "https://active.url",
+        livekit_alias: "!active:active.url",
+    };
+
+    beforeEach(() => {
+        // Default to fake timers.
+        jest.useFakeTimers();
+        client = makeMockClient("@alice:example.org", "AAAAAAA");
+        room = makeMockRoom(membershipTemplate);
+        // Provide a default mock that is like the default "non error" server behaviour.
+        (client._unstable_sendDelayedStateEvent as Mock<any>).mockResolvedValue({ delay_id: "id" });
+        (client._unstable_updateDelayedEvent as Mock<any>).mockResolvedValue(undefined);
+        (client.sendStateEvent as Mock<any>).mockResolvedValue(undefined);
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+        // There is no need to clean up mocks since we will recreate the client.
+    });
+
+    describe("isActivated()", () => {
+        it("defaults to false", () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            expect(manager.isActivated()).toEqual(false);
+        });
+
+        it("returns true after join()", () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([]);
+            expect(manager.isActivated()).toEqual(true);
+        });
+    });
+
+    describe("join()", () => {
+        describe("sends a membership event", () => {
+            it("sends a membership event and schedules delayed leave when joining a call", async () => {
+                // Spys/Mocks
+
+                const updateDelayedEventHandle = createAsyncHandle(client._unstable_updateDelayedEvent as Mock);
+
+                // Test
+                const memberManager = new TestMembershipManager(undefined, room, client, () => undefined);
+                memberManager.join([focus], focusActive);
+                // expects
+                await waitForMockCall(client.sendStateEvent);
+                expect(client.sendStateEvent).toHaveBeenCalledWith(
+                    room.roomId,
+                    "org.matrix.msc3401.call.member",
+                    {
+                        application: "m.call",
+                        call_id: "",
+                        device_id: "AAAAAAA",
+                        expires: 14400000,
+                        foci_preferred: [focus],
+                        focus_active: focusActive,
+                        scope: "m.room",
+                    },
+                    "_@alice:example.org_AAAAAAA",
+                );
+                updateDelayedEventHandle.resolve?.();
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledWith(
+                    room.roomId,
+                    { delay: 8000 },
+                    "org.matrix.msc3401.call.member",
+                    {},
+                    "_@alice:example.org_AAAAAAA",
+                );
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
+            });
+
+            it("reschedules delayed leave event if sending state cancels it", async () => {
+                const memberManager = new TestMembershipManager(undefined, room, client, () => undefined);
+                const waitForSendState = waitForMockCall(client.sendStateEvent);
+                const waitForUpdateDelaye = waitForMockCallOnce(
+                    client._unstable_updateDelayedEvent,
+                    Promise.reject(new MatrixError({ errcode: "M_NOT_FOUND" })),
+                );
+                memberManager.join([focus], focusActive);
+                await waitForSendState;
+                await waitForUpdateDelaye;
+                await jest.advanceTimersByTimeAsync(1);
+                // Once for the initial event and once because of the errcode: "M_NOT_FOUND"
+                // Different to "sends a membership event and schedules delayed leave when joining a call" where its only called once (1)
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(2);
+            });
+
+            describe("does not prefix the state key with _ for rooms that support user-owned state events", () => {
+                async function testJoin(useOwnedStateEvents: boolean): Promise<void> {
+                    // TODO: this test does quiet a bit. Its more a like a test story summarizing to:
+                    // - send delay with too long timeout and get server error (test delayedEventTimeout gets overwritten)
+                    // - run into rate limit for sending delayed event
+                    // - run into rate limit when setting membership state.
+                    if (useOwnedStateEvents) {
+                        room.getVersion = jest.fn().mockReturnValue("org.matrix.msc3757.default");
+                    }
+                    const updatedDelayedEvent = waitForMockCall(client._unstable_updateDelayedEvent);
+                    const sentDelayedState = waitForMockCall(
+                        client._unstable_sendDelayedStateEvent,
+                        Promise.resolve({
+                            delay_id: "id",
+                        }),
+                    );
+
+                    // preparing the delayed disconnect should handle the delay being too long
+                    const sendDelayedStateExceedAttempt = new Promise<void>((resolve) => {
+                        const error = new MatrixError({
+                            "errcode": "M_UNKNOWN",
+                            "org.matrix.msc4140.errcode": "M_MAX_DELAY_EXCEEDED",
+                            "org.matrix.msc4140.max_delay": 7500,
+                        });
+                        (client._unstable_sendDelayedStateEvent as Mock).mockImplementationOnce(() => {
+                            resolve();
+                            return Promise.reject(error);
+                        });
+                    });
+
+                    const userStateKey = `${!useOwnedStateEvents ? "_" : ""}@alice:example.org_AAAAAAA`;
+                    // preparing the delayed disconnect should handle ratelimiting
+                    const sendDelayedStateAttempt = new Promise<void>((resolve) => {
+                        const error = new MatrixError({ errcode: "M_LIMIT_EXCEEDED" });
+                        (client._unstable_sendDelayedStateEvent as Mock).mockImplementationOnce(() => {
+                            resolve();
+                            return Promise.reject(error);
+                        });
+                    });
+
+                    // setting the membership state should handle ratelimiting (also with a retry-after value)
+                    const sendStateEventAttempt = new Promise<void>((resolve) => {
+                        const error = new MatrixError(
+                            { errcode: "M_LIMIT_EXCEEDED" },
+                            429,
+                            undefined,
+                            undefined,
+                            new Headers({ "Retry-After": "1" }),
+                        );
+                        (client.sendStateEvent as Mock).mockImplementationOnce(() => {
+                            resolve();
+                            return Promise.reject(error);
+                        });
+                    });
+                    const manager = new TestMembershipManager(
+                        {
+                            membershipServerSideExpiryTimeout: 9000,
+                        },
+                        room,
+                        client,
+                        () => undefined,
+                    );
+                    manager.join([focus], focusActive);
+
+                    await sendDelayedStateExceedAttempt.then(); // needed to resolve after the send attempt catches
+                    await sendDelayedStateAttempt;
+                    const callProps = (d: number) => {
+                        return [room!.roomId, { delay: d }, "org.matrix.msc3401.call.member", {}, userStateKey];
+                    };
+                    expect(client._unstable_sendDelayedStateEvent).toHaveBeenNthCalledWith(1, ...callProps(9000));
+                    expect(client._unstable_sendDelayedStateEvent).toHaveBeenNthCalledWith(2, ...callProps(7500));
+
+                    await jest.advanceTimersByTimeAsync(5000);
+
+                    await sendStateEventAttempt.then(); // needed to resolve after resendIfRateLimited catches
+
+                    await jest.advanceTimersByTimeAsync(1000);
+
+                    expect(client.sendStateEvent).toHaveBeenCalledWith(
+                        room!.roomId,
+                        EventType.GroupCallMemberPrefix,
+                        {
+                            application: "m.call",
+                            scope: "m.room",
+                            call_id: "",
+                            expires: 14400000,
+                            device_id: "AAAAAAA",
+                            foci_preferred: [focus],
+                            focus_active: focusActive,
+                        } satisfies SessionMembershipData,
+                        userStateKey,
+                    );
+                    await sentDelayedState;
+
+                    // should have prepared the heartbeat to keep delaying the leave event while still connected
+                    await updatedDelayedEvent;
+                    expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
+
+                    // ensures that we reach the code that schedules the timeout for the next delay update before we advance the timers.
+                    await jest.advanceTimersByTimeAsync(5000);
+                    // should update delayed disconnect
+                    expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(2);
+                }
+
+                it("sends a membership event after rate limits during delayed event setup when joining a call", async () => {
+                    await testJoin(false);
+                });
+
+                it("does not prefix the state key with _ for rooms that support user-owned state events", async () => {
+                    await testJoin(true);
+                });
+            });
+        });
+
+        describe("delayed leave event", () => {
+            it("does not try again to schedule a delayed leave event if not supported", () => {
+                const delayedHandle = createAsyncHandle(client._unstable_sendDelayedStateEvent as Mock);
+                const manager = new TestMembershipManager({}, room, client, () => undefined);
+                manager.join([focus], focusActive);
+                delayedHandle.reject?.(
+                    new UnsupportedDelayedEventsEndpointError(
+                        "Server does not support the delayed events API",
+                        "sendDelayedStateEvent",
+                    ),
+                );
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
+            });
+            it("does try to schedule a delayed leave event again if rate limited", async () => {
+                const delayedHandle = createAsyncHandle(client._unstable_sendDelayedStateEvent as Mock);
+                const manager = new TestMembershipManager({}, room, client, () => undefined);
+                manager.join([focus], focusActive);
+                delayedHandle.reject?.(new HTTPError("rate limited", 429, undefined));
+                await jest.advanceTimersByTimeAsync(5000);
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(2);
+            });
+            it("uses membershipServerSideExpiryTimeout from config", () => {
+                const manager = new TestMembershipManager(
+                    { membershipServerSideExpiryTimeout: 123456 },
+                    room,
+                    client,
+                    () => undefined,
+                );
+                manager.join([focus], focusActive);
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledWith(
+                    room.roomId,
+                    { delay: 123456 },
+                    "org.matrix.msc3401.call.member",
+                    {},
+                    "_@alice:example.org_AAAAAAA",
+                );
+            });
+        });
+
+        it("uses membershipExpiryTimeout from config", async () => {
+            const manager = new TestMembershipManager(
+                { membershipExpiryTimeout: 1234567 },
+                room,
+                client,
+                () => undefined,
+            );
+
+            manager.join([focus], focusActive);
+            await waitForMockCall(client.sendStateEvent);
+            expect(client.sendStateEvent).toHaveBeenCalledWith(
+                room.roomId,
+                EventType.GroupCallMemberPrefix,
+                {
+                    application: "m.call",
+                    scope: "m.room",
+                    call_id: "",
+                    device_id: "AAAAAAA",
+                    expires: 1234567,
+                    foci_preferred: [focus],
+                    focus_active: {
+                        focus_selection: "oldest_membership",
+                        type: "livekit",
+                    },
+                },
+                "_@alice:example.org_AAAAAAA",
+            );
+        });
+
+        it("does nothing if join called when already joined", async () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], focusActive);
+            await waitForMockCall(client.sendStateEvent);
+            expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
+            manager.join([focus], focusActive);
+            expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe("leave()", () => {
+        // TODO add rate limit cases.
+        it("resolves delayed leave event when leave is called", async () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], focusActive);
+            await jest.advanceTimersByTimeAsync(1);
+            await manager.leave();
+            expect(client._unstable_updateDelayedEvent).toHaveBeenLastCalledWith("id", "send");
+            expect(client.sendStateEvent).toHaveBeenCalled();
+        });
+        it("send leave event when leave is called and resolving delayed leave fails", async () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], focusActive);
+            await jest.advanceTimersByTimeAsync(1);
+            (client._unstable_updateDelayedEvent as Mock<any>).mockRejectedValue("unknown");
+            await manager.leave();
+
+            // We send a normal leave event since we failed using updateDelayedEvent with the "send" action.
+            expect(client.sendStateEvent).toHaveBeenLastCalledWith(
+                room.roomId,
+                "org.matrix.msc3401.call.member",
+                {},
+                "_@alice:example.org_AAAAAAA",
+            );
+        });
+        // FailsForLegacy because legacy implementation always sends the empty state event even though it isn't needed
+        it("does nothing if not joined !FailsForLegacy", () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            expect(async () => await manager.leave()).not.toThrow();
+            expect(client._unstable_sendDelayedStateEvent).not.toHaveBeenCalled();
+            expect(client.sendStateEvent).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("getsActiveFocus", () => {
+        it("gets the correct active focus with oldest_membership", () => {
+            const getOldestMembership = jest.fn();
+            const manager = new TestMembershipManager({}, room, client, getOldestMembership);
+            // Before joining the active focus should be undefined (see FocusInUse on MatrixRTCSession)
+            expect(manager.getActiveFocus()).toBe(undefined);
+            manager.join([focus], focusActive);
+            // After joining we want our own focus to be the one we select.
+            getOldestMembership.mockReturnValue(
+                mockCallMembership(
+                    {
+                        ...membershipTemplate,
+                        foci_preferred: [
+                            {
+                                livekit_alias: "!active:active.url",
+                                livekit_service_url: "https://active.url",
+                                type: "livekit",
+                            },
+                        ],
+                        device_id: client.getDeviceId(),
+                        created_ts: 1000,
+                    },
+                    room.roomId,
+                    client.getUserId()!,
+                ),
+            );
+            expect(manager.getActiveFocus()).toStrictEqual(focus);
+            getOldestMembership.mockReturnValue(
+                mockCallMembership(
+                    Object.assign({}, membershipTemplate, { device_id: "old", created_ts: 1000 }),
+                    room.roomId,
+                ),
+            );
+            // If there is an older member we use its focus.
+            expect(manager.getActiveFocus()).toBe(membershipTemplate.foci_preferred[0]);
+        });
+
+        it("does not provide focus if the selection method is unknown", () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], Object.assign(focusActive, { type: "unknown_type" }));
+            expect(manager.getActiveFocus()).toBe(undefined);
+        });
+    });
+
+    describe("onRTCSessionMemberUpdate()", () => {
+        it("does nothing if not joined", async () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            await manager.onRTCSessionMemberUpdate([mockCallMembership(membershipTemplate, room.roomId)]);
+            await jest.advanceTimersToNextTimerAsync();
+            expect(client.sendStateEvent).not.toHaveBeenCalled();
+            expect(client._unstable_sendDelayedStateEvent).not.toHaveBeenCalled();
+            expect(client._unstable_updateDelayedEvent).not.toHaveBeenCalled();
+        });
+        it("does nothing if own membership still present", async () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], focusActive);
+            await jest.advanceTimersByTimeAsync(1);
+            const myMembership = (client.sendStateEvent as Mock).mock.calls[0][2];
+            // reset all mocks before checking what happens when calling: `onRTCSessionMemberUpdate`
+            (client.sendStateEvent as Mock).mockClear();
+            (client._unstable_updateDelayedEvent as Mock).mockClear();
+            (client._unstable_sendDelayedStateEvent as Mock).mockClear();
+
+            await manager.onRTCSessionMemberUpdate([
+                mockCallMembership(membershipTemplate, room.roomId),
+                mockCallMembership(myMembership as SessionMembershipData, room.roomId, client.getUserId() ?? undefined),
+            ]);
+
+            await jest.advanceTimersByTimeAsync(1);
+
+            expect(client.sendStateEvent).not.toHaveBeenCalled();
+            expect(client._unstable_sendDelayedStateEvent).not.toHaveBeenCalled();
+            expect(client._unstable_updateDelayedEvent).not.toHaveBeenCalled();
+        });
+        it("recreates membership if it is missing", async () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], focusActive);
+            await jest.advanceTimersByTimeAsync(1);
+            // clearing all mocks before checking what happens when calling: `onRTCSessionMemberUpdate`
+            (client.sendStateEvent as Mock).mockClear();
+            (client._unstable_updateDelayedEvent as Mock).mockClear();
+            (client._unstable_sendDelayedStateEvent as Mock).mockClear();
+
+            // Our own membership is removed:
+            await manager.onRTCSessionMemberUpdate([mockCallMembership(membershipTemplate, room.roomId)]);
+            await jest.advanceTimersByTimeAsync(1);
+            expect(client.sendStateEvent).toHaveBeenCalled();
+            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalled();
+
+            expect(client._unstable_updateDelayedEvent).toHaveBeenCalled();
+        });
+    });
+
+    // TODO: Not sure about this name
+    describe("background timers", () => {
+        it("sends only one keep-alive for delayed leave event per `membershipKeepAlivePeriod`", async () => {
+            const manager = new TestMembershipManager(
+                { membershipKeepAlivePeriod: 10_000, membershipServerSideExpiryTimeout: 30_000 },
+                room,
+                client,
+                () => undefined,
+            );
+            manager.join([focus], focusActive);
+            await jest.advanceTimersByTimeAsync(1);
+            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
+
+            // The first call is from checking id the server deleted the delayed event
+            // so it does not need a `advanceTimersByTime`
+            expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
+            // TODO: Check that update delayed event is called with the correct HTTP request timeout
+            // expect(client._unstable_updateDelayedEvent).toHaveBeenLastCalledWith("id", 10_000, { localTimeoutMs: 20_000 });
+
+            for (let i = 2; i <= 12; i++) {
+                // flush promises before advancing the timers to make sure schedulers are setup
+                await jest.advanceTimersByTimeAsync(10_000);
+
+                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(i);
+                // TODO: Check that update delayed event is called with the correct HTTP request timeout
+                // expect(client._unstable_updateDelayedEvent).toHaveBeenLastCalledWith("id", 10_000, { localTimeoutMs: 20_000 });
+            }
+        });
+
+        // !FailsForLegacy because the expires logic was removed for the legacy call manager.
+        // Delayed events should replace it entirely but before they have wide adoption
+        // the expiration logic still makes sense.
+        // TODO: Add git commit when we removed it.
+        async function testExpires(expire: number, headroom?: number) {
+            const manager = new TestMembershipManager(
+                { membershipExpiryTimeout: expire, membershipExpiryTimeoutHeadroom: headroom },
+                room,
+                client,
+                () => undefined,
+            );
+            manager.join([focus], focusActive);
+            await waitForMockCall(client.sendStateEvent);
+            expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
+            const sentMembership = (client.sendStateEvent as Mock).mock.calls[0][2] as SessionMembershipData;
+            expect(sentMembership.expires).toBe(expire);
+            for (let i = 2; i <= 12; i++) {
+                await jest.advanceTimersByTimeAsync(expire);
+                expect(client.sendStateEvent).toHaveBeenCalledTimes(i);
+                const sentMembership = (client.sendStateEvent as Mock).mock.lastCall![2] as SessionMembershipData;
+                expect(sentMembership.expires).toBe(expire * i);
+            }
+        }
+        it("extends `expires` when call still active !FailsForLegacy", async () => {
+            await testExpires(10_000);
+        });
+        it("extends `expires` using headroom configuration !FailsForLegacy", async () => {
+            await testExpires(10_000, 1_000);
+        });
+    });
+    describe("status updates", () => {
+        it("starts 'Disconnected' !FailsForLegacy", () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            expect(manager.status).toBe(Status.Disconnected);
+        });
+        it("emits 'Connection' and 'Connected' after join !FailsForLegacy", async () => {
+            const handleDelayedEvent = createAsyncHandle(client._unstable_sendDelayedStateEvent);
+            const handleStateEvent = createAsyncHandle(client.sendStateEvent);
+
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            expect(manager.status).toBe(Status.Disconnected);
+            const connectEmit = jest.fn();
+            manager.on(MembershipManagerEvent.StatusChanged, connectEmit);
+            manager.join([focus], focusActive);
+            expect(manager.status).toBe(Status.Connecting);
+            handleDelayedEvent.resolve();
+            await jest.advanceTimersByTimeAsync(1);
+            expect(connectEmit).toHaveBeenCalledWith(Status.Disconnected, Status.Connecting);
+            handleStateEvent.resolve();
+            await jest.advanceTimersByTimeAsync(1);
+            expect(connectEmit).toHaveBeenCalledWith(Status.Connecting, Status.Connected);
+        });
+        it("emits 'Disconnecting' and 'Disconnected' after leave !FailsForLegacy", async () => {
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            const connectEmit = jest.fn();
+            manager.on(MembershipManagerEvent.StatusChanged, connectEmit);
+            manager.join([focus], focusActive);
+            await jest.advanceTimersByTimeAsync(1);
+            await manager.leave();
+            expect(connectEmit).toHaveBeenCalledWith(Status.Connected, Status.Disconnecting);
+            expect(connectEmit).toHaveBeenCalledWith(Status.Disconnecting, Status.Disconnected);
+        });
+    });
+    describe("server error handling", () => {
+        // Types of server error: 429 rate limit with no retry-after header, 429 with retry-after, 50x server error (maybe retry every second), connection/socket timeout
+        describe("retries sending delayed leave event", () => {
+            it("sends retry if call membership event is still valid at time of retry", async () => {
+                const handle = createAsyncHandle(client._unstable_sendDelayedStateEvent);
+
+                const manager = new TestMembershipManager({}, room, client, () => undefined);
+                manager.join([focus], focusActive);
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
+
+                handle.reject?.(
+                    new MatrixError(
+                        { errcode: "M_LIMIT_EXCEEDED" },
+                        429,
+                        undefined,
+                        undefined,
+                        new Headers({ "Retry-After": "1" }),
+                    ),
+                );
+                await jest.advanceTimersByTimeAsync(1000);
+
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(2);
+            });
+            // FailsForLegacy as implementation does not re-check membership before retrying.
+            it("abandons retry loop and sends new own membership if not present anymore !FailsForLegacy", async () => {
+                (client._unstable_sendDelayedStateEvent as any).mockRejectedValue(
+                    new MatrixError(
+                        { errcode: "M_LIMIT_EXCEEDED" },
+                        429,
+                        undefined,
+                        undefined,
+                        new Headers({ "Retry-After": "1" }),
+                    ),
+                );
+                const manager = new TestMembershipManager({}, room, client, () => undefined);
+                // Should call _unstable_sendDelayedStateEvent but not sendStateEvent because of the
+                // RateLimit error.
+                manager.join([focus], focusActive);
+                await jest.advanceTimersByTimeAsync(1);
+
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
+                (client._unstable_sendDelayedStateEvent as Mock<any>).mockResolvedValue({ delay_id: "id" });
+                // Remove our own membership so that there is no reason the send the delayed leave anymore.
+                // the membership is no longer present on the homeserver
+                await manager.onRTCSessionMemberUpdate([]);
+                // Wait for all timers to be setup
+                await jest.advanceTimersByTimeAsync(1000);
+                // We should send the first own membership and a new delayed event after the rate limit timeout.
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(2);
+                expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
+            });
+            // FailsForLegacy as implementation does not re-check membership before retrying.
+            it("abandons retry loop if leave() was called before sending state event !FailsForLegacy", async () => {
+                const handle = createAsyncHandle(client._unstable_sendDelayedStateEvent);
+
+                const manager = new TestMembershipManager({}, room, client, () => undefined);
+                manager.join([focus], focusActive);
+                handle.reject?.(
+                    new MatrixError(
+                        { errcode: "M_LIMIT_EXCEEDED" },
+                        429,
+                        undefined,
+                        undefined,
+                        new Headers({ "Retry-After": "1" }),
+                    ),
+                );
+
+                await jest.advanceTimersByTimeAsync(1);
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
+                // the user terminated the call locally
+                await manager.leave();
+
+                // Wait for all timers to be setup
+                await jest.advanceTimersByTimeAsync(1000);
+
+                // No new events should have been sent:
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
+            });
+        });
+        describe("retries sending update delayed leave event restart", () => {
+            it("resends the initial check delayed update event !FailsForLegacy", async () => {
+                (client._unstable_updateDelayedEvent as Mock<any>).mockRejectedValue(
+                    new MatrixError(
+                        { errcode: "M_LIMIT_EXCEEDED" },
+                        429,
+                        undefined,
+                        undefined,
+                        new Headers({ "Retry-After": "1" }),
+                    ),
+                );
+                const manager = new TestMembershipManager({}, room, client, () => undefined);
+                manager.join([focus], focusActive);
+
+                // Hit rate limit
+                await jest.advanceTimersByTimeAsync(1);
+                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
+
+                // Hit second rate limit.
+                await jest.advanceTimersByTimeAsync(1000);
+                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(2);
+
+                // Setup resolve
+                (client._unstable_updateDelayedEvent as Mock<any>).mockResolvedValue(undefined);
+                await jest.advanceTimersByTimeAsync(1000);
+
+                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(3);
+                expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
+            });
+        });
+    });
+    describe("unrecoverable errors", () => {
+        // !FailsForLegacy because legacy does not have a retry limit and no mechanism to communicate unrecoverable errors.
+        it("throws, when reaching maximum number of retries for initial delayed event creation !FailsForLegacy", async () => {
+            const delayEventSendError = jest.fn();
+            (client._unstable_sendDelayedStateEvent as Mock<any>).mockRejectedValue(
+                new MatrixError(
+                    { errcode: "M_LIMIT_EXCEEDED" },
+                    429,
+                    undefined,
+                    undefined,
+                    new Headers({ "Retry-After": "2" }),
+                ),
+            );
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], focusActive, delayEventSendError);
+
+            for (let i = 0; i < 10; i++) {
+                await jest.advanceTimersByTimeAsync(2000);
+            }
+            expect(delayEventSendError).toHaveBeenCalled();
+        });
+        // !FailsForLegacy because legacy does not have a retry limit and no mechanism to communicate unrecoverable errors.
+        it("throws, when reaching maximum number of retries !FailsForLegacy", async () => {
+            const delayEventRestartError = jest.fn();
+            (client._unstable_updateDelayedEvent as Mock<any>).mockRejectedValue(
+                new MatrixError(
+                    { errcode: "M_LIMIT_EXCEEDED" },
+                    429,
+                    undefined,
+                    undefined,
+                    new Headers({ "Retry-After": "1" }),
+                ),
+            );
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], focusActive, delayEventRestartError);
+
+            for (let i = 0; i < 10; i++) {
+                await jest.advanceTimersByTimeAsync(1000);
+            }
+            expect(delayEventRestartError).toHaveBeenCalled();
+        });
+        it("falls back to using pure state events when some error occurs while sending delayed events !FailsForLegacy", async () => {
+            const unrecoverableError = jest.fn();
+            (client._unstable_sendDelayedStateEvent as Mock<any>).mockRejectedValue(new HTTPError("unknown", 601));
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], focusActive, unrecoverableError);
+            await waitForMockCall(client.sendStateEvent);
+            expect(unrecoverableError).not.toHaveBeenCalledWith();
+            expect(client.sendStateEvent).toHaveBeenCalled();
+        });
+        it("retries before failing in case its a network error !FailsForLegacy", async () => {
+            const unrecoverableError = jest.fn();
+            (client._unstable_sendDelayedStateEvent as Mock<any>).mockRejectedValue(new HTTPError("unknown", 501));
+            const manager = new TestMembershipManager(
+                { callMemberEventRetryDelayMinimum: 1000, maximumNetworkErrorRetryCount: 7 },
+                room,
+                client,
+                () => undefined,
+            );
+            manager.join([focus], focusActive, unrecoverableError);
+            for (let retries = 0; retries < 7; retries++) {
+                expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(retries + 1);
+                await jest.advanceTimersByTimeAsync(1000);
+            }
+            expect(unrecoverableError).toHaveBeenCalled();
+            expect(unrecoverableError.mock.lastCall![0].message).toMatch(
+                "The MembershipManager shut down because of the end condition",
+            );
+            expect(client.sendStateEvent).not.toHaveBeenCalled();
+        });
+        it("falls back to using pure state events when UnsupportedDelayedEventsEndpointError encountered for delayed events !FailsForLegacy", async () => {
+            const unrecoverableError = jest.fn();
+            (client._unstable_sendDelayedStateEvent as Mock<any>).mockRejectedValue(
+                new UnsupportedDelayedEventsEndpointError("not supported", "sendDelayedStateEvent"),
+            );
+            const manager = new TestMembershipManager({}, room, client, () => undefined);
+            manager.join([focus], focusActive, unrecoverableError);
+            await jest.advanceTimersByTimeAsync(1);
+
+            expect(unrecoverableError).not.toHaveBeenCalled();
+            expect(client.sendStateEvent).toHaveBeenCalled();
+        });
+    });
+});
@@ -0,0 +1,54 @@
+/*
+Copyright 2025 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 file adds a custom test environment for the MembershipManager.spec.ts
+It can be used with the comment at the top of the file:
+
+@jest-environment ./spec/unit/matrixrtc/memberManagerTestEnvironment.ts
+
+It is very specific to the MembershipManager.spec.ts file and introduces the following behaviour:
+ - The describe each block in the MembershipManager.spec.ts will go through describe block names `LegacyMembershipManager` and `MembershipManager`
+ - It will check all tests that are a child or indirect child of the `LegacyMembershipManager` block and skip the ones which include "!FailsForLegacy"
+   in their test name.
+*/
+
+import { TestEnvironment } from "jest-environment-jsdom";
+
+import { logger as rootLogger } from "../../../src/logger";
+const logger = rootLogger.getChild("MatrixRTCSession");
+
+class MemberManagerTestEnvironment extends TestEnvironment {
+    handleTestEvent(event: any) {
+        if (event.name === "test_start" && event.test.name.includes("!FailsForLegacy")) {
+            let parent = event.test.parent;
+            let isLegacy = false;
+            while (parent) {
+                if (parent.name === "LegacyMembershipManager") {
+                    isLegacy = true;
+                    break;
+                } else {
+                    parent = parent.parent;
+                }
+            }
+            if (isLegacy) {
+                logger.info("skip test: ", event.test.name);
+                event.test.mode = "skip";
+            }
+        }
+    }
+}
+module.exports = MemberManagerTestEnvironment;
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { EventType, MatrixEvent, Room } from "../../../src";
-import { SessionMembershipData } from "../../../src/matrixrtc/CallMembership";
+import { EventType, type MatrixClient, type MatrixEvent, type Room } from "../../../src";
+import { CallMembership, type SessionMembershipData } from "../../../src/matrixrtc/CallMembership";
 import { secureRandomString } from "../../../src/randomstring";

 type MembershipData = SessionMembershipData[] | SessionMembershipData | {};
@@ -25,7 +25,7 @@ export const membershipTemplate: SessionMembershipData = {
    call_id: "",
    device_id: "AAAAAAA",
    scope: "m.room",
-    focus_active: { type: "livekit", livekit_service_url: "https://lk.url" },
+    focus_active: { type: "livekit", focus_selection: "oldest_membership" },
    foci_preferred: [
        {
            livekit_alias: "!alias:something.org",
@@ -40,6 +40,31 @@ export const membershipTemplate: SessionMembershipData = {
    ],
 };

+export type MockClient = Pick<
+    MatrixClient,
+    | "getUserId"
+    | "getDeviceId"
+    | "sendEvent"
+    | "sendStateEvent"
+    | "_unstable_sendDelayedStateEvent"
+    | "_unstable_updateDelayedEvent"
+    | "cancelPendingEvent"
+>;
+/**
+ * Mocks a object that has all required methods for a MatrixRTC session client.
+ */
+export function makeMockClient(userId: string, deviceId: string): MockClient {
+    return {
+        getDeviceId: () => deviceId,
+        getUserId: () => userId,
+        sendEvent: jest.fn(),
+        sendStateEvent: jest.fn(),
+        cancelPendingEvent: jest.fn(),
+        _unstable_updateDelayedEvent: jest.fn(),
+        _unstable_sendDelayedStateEvent: jest.fn(),
+    };
+}
+
 export function makeMockRoom(membershipData: MembershipData): Room {
    const roomId = secureRandomString(8);
    // Caching roomState here so it does not get recreated when calling `getLiveTimeline.getState()`
@@ -88,16 +113,17 @@ export function makeMockRoomState(membershipData: MembershipData, roomId: string
    };
 }

-export function mockRTCEvent(membershipData: MembershipData, roomId: string): MatrixEvent {
+export function mockRTCEvent(membershipData: MembershipData, roomId: string, customSender?: string): MatrixEvent {
+    const sender = customSender ?? "@mock:user.example";
    return {
        getType: jest.fn().mockReturnValue(EventType.GroupCallMemberPrefix),
        getContent: jest.fn().mockReturnValue(membershipData),
-        getSender: jest.fn().mockReturnValue("@mock:user.example"),
+        getSender: jest.fn().mockReturnValue(sender),
        getTs: jest.fn().mockReturnValue(Date.now()),
        getRoomId: jest.fn().mockReturnValue(roomId),
-        sender: {
-            userId: "@mock:user.example",
-        },
        isDecryptionFailure: jest.fn().mockReturnValue(false),
    } as unknown as MatrixEvent;
 }
+export function mockCallMembership(membershipData: MembershipData, roomId: string, sender?: string): CallMembership {
+    return new CallMembership(mockRTCEvent(membershipData, roomId, sender), membershipData);
+}
@@ -14,14 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

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

 describe("MSC3089Branch", () => {
    let client: MatrixClient;
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { IContent, MatrixClient } from "../../../src";
-import { Room } from "../../../src/models/room";
+import { type IContent, type MatrixClient } from "../../../src";
+import { type Room } from "../../../src/models/room";
 import { MatrixEvent } from "../../../src/models/event";
 import { EventType, MsgType, UNSTABLE_MSC3089_BRANCH, UNSTABLE_MSC3089_LEAF } from "../../../src/@types/event";
 import {
@@ -26,7 +26,7 @@ import {
 import { DEFAULT_ALPHABET } from "../../../src/utils";
 import { MatrixError } from "../../../src/http-api";
 import { KnownMembership } from "../../../src/@types/membership";
-import { EncryptedFile } from "../../../src/@types/media";
+import { type EncryptedFile } from "../../../src/@types/media";

 describe("MSC3089TreeSpace", () => {
    let client: MatrixClient;
@@ -14,21 +14,24 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { MockedObject } from "jest-mock";
+import { type MockedObject } from "jest-mock";

 import { MatrixEvent, MatrixEventEvent } from "../../../src/models/event";
 import { emitPromise } from "../../test-utils/test-utils";
-import { Crypto, IEventDecryptionResult } from "../../../src/crypto";
 import {
-    IAnnotatedPushRule,
-    MatrixClient,
+    type IAnnotatedPushRule,
+    type MatrixClient,
    PushRuleActionName,
    Room,
    THREAD_RELATION_TYPE,
    TweakName,
 } from "../../../src";
 import { DecryptionFailureCode } from "../../../src/crypto-api";
-import { DecryptionError } from "../../../src/common-crypto/CryptoBackend";
+import {
+    type CryptoBackend,
+    DecryptionError,
+    type EventDecryptionResult,
+} from "../../../src/common-crypto/CryptoBackend";

 describe("MatrixEvent", () => {
    it("should create copies of itself", () => {
@@ -369,7 +372,7 @@ describe("MatrixEvent", () => {
            const testError = new Error("test error");
            const crypto = {
                decryptEvent: jest.fn().mockRejectedValue(testError),
-            } as unknown as Crypto;
+            } as unknown as CryptoBackend;

            await encryptedEvent.attemptDecryption(crypto);
            expect(encryptedEvent.isEncrypted()).toBeTruthy();
@@ -391,7 +394,7 @@ describe("MatrixEvent", () => {
            const testError = new DecryptionError(DecryptionFailureCode.MEGOLM_UNKNOWN_INBOUND_SESSION_ID, "uisi");
            const crypto = {
                decryptEvent: jest.fn().mockRejectedValue(testError),
-            } as unknown as Crypto;
+            } as unknown as CryptoBackend;

            await encryptedEvent.attemptDecryption(crypto);
            expect(encryptedEvent.isEncrypted()).toBeTruthy();
@@ -418,7 +421,7 @@ describe("MatrixEvent", () => {
                            "The sender has disabled encrypting to unverified devices.",
                        ),
                    ),
-            } as unknown as Crypto;
+            } as unknown as CryptoBackend;

            await encryptedEvent.attemptDecryption(crypto);
            expect(encryptedEvent.isEncrypted()).toBeTruthy();
@@ -453,7 +456,7 @@ describe("MatrixEvent", () => {
                            },
                        });
                    }),
-            } as unknown as Crypto;
+            } as unknown as CryptoBackend;

            await encryptedEvent.attemptDecryption(crypto);

@@ -478,7 +481,7 @@ describe("MatrixEvent", () => {

            const crypto = {
                decryptEvent: jest.fn().mockImplementationOnce(() => {
-                    return Promise.resolve<IEventDecryptionResult>({
+                    return Promise.resolve<EventDecryptionResult>({
                        clearEvent: {
                            type: "m.room.message",
                            content: {
@@ -491,7 +494,7 @@ describe("MatrixEvent", () => {
                        },
                    });
                }),
-            } as unknown as Crypto;
+            } as unknown as CryptoBackend;

            await encryptedEvent.attemptDecryption(crypto);
            expect(encryptedEvent.getType()).toEqual("m.room.message");
@@ -16,7 +16,7 @@ limitations under the License.

 import { M_POLL_START } from "matrix-events-sdk";

-import { EventType, IEvent, MatrixEvent, PollEvent, Room } from "../../../src";
+import { EventType, type IEvent, MatrixEvent, PollEvent, Room } from "../../../src";
 import { REFERENCE_RELATION } from "../../../src/@types/extensible_events";
 import { M_POLL_END, M_POLL_KIND_DISCLOSED, M_POLL_RESPONSE } from "../../../src/@types/polls";
 import { PollStartEvent } from "../../../src/extensible_events_v1/PollStartEvent";
@@ -14,7 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { FeatureSupport, MatrixClient, MatrixEvent, ReceiptContent, THREAD_RELATION_TYPE, Thread } from "../../../src";
+import {
+    FeatureSupport,
+    type MatrixClient,
+    MatrixEvent,
+    type ReceiptContent,
+    THREAD_RELATION_TYPE,
+    Thread,
+} from "../../../src";
 import { Room } from "../../../src/models/room";

 /**
--- a/Show More
+++ b/Show More