v37.0.0

v37.0.0-rc.0
Mention caveat in README about IndexedDB outside browser (#4712 )
2025-02-25 13:11:01 +00:00 · 2025-02-18 12:59:47 +00:00 · 2025-02-18 10:25:06 +00:00 · 2025-02-17 14:43:08 +00:00 · 2025-02-17 09:53:22 +00:00 · 2025-02-14 14:32:33 +00:00
343 changed files with 7148 additions and 35589 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,7 @@ 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",
            },
        },
    ],
@@ -15,7 +15,7 @@ jobs:
        name: Preview Changelog
        runs-on: ubuntu-24.04
        steps:
-            - uses: mheap/github-action-required-labels@d25134c992b943fb6ad00c25ea00eb5988c0a9dd # v5
+            - uses: mheap/github-action-required-labels@388fd6af37b34cdfe5a23b37060e763217e58b03 # v5
              if: github.event_name != 'merge_group'
              with:
                  labels: |
@@ -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@66088c44e212a906c32a047529a213d81809ec1c
+            - uses: guibranco/github-status-action-v2@119b3320db3f04d89e91df840844b92d57ce3468
              with:
                  authToken: ${{ secrets.GITHUB_TOKEN }}
                  state: pending
@@ -70,7 +70,7 @@ jobs:
              run: |
                  coverage=$(find coverage -type f -name '*lcov.info' -printf '%h/%f,' | tr -d '\r\n' | sed 's/,$//g')
                  echo "sonar.javascript.lcov.reportPaths=$coverage" >> sonar-project.properties
-                  reports=$(find coverage -type f -name 'jest-sonar-report*.xml' -printf '%h/%f,' | tr -d '\r\n' | sed 's/,$//g')
+                  reports=$(find coverage -type f -name '*sonar-report*.xml' -printf '%h/%f,' | tr -d '\r\n' | sed 's/,$//g')
                  echo "sonar.testExecutionReportPaths=$reports" >> sonar-project.properties

            - name: "🩻 SonarCloud Scan"
@@ -87,7 +87,7 @@ jobs:
                  revision: ${{ github.event.workflow_run.head_sha }}
                  token: ${{ secrets.SONAR_TOKEN }}

-            - uses: guibranco/github-status-action-v2@66088c44e212a906c32a047529a213d81809ec1c
+            - uses: guibranco/github-status-action-v2@119b3320db3f04d89e91df840844b92d57ce3468
              if: always()
              with:
                  authToken: ${{ secrets.GITHUB_TOKEN }}
@@ -44,6 +44,41 @@ jobs:
            - name: Run Linter
              run: "yarn run lint:js"

+    node_example_lint:
+        name: "Node.js example"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version-file: package.json
+
+            - name: Install Deps
+              run: "yarn install"
+
+            - name: Build Types
+              run: "yarn build:types"
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "npm"
+                  node-version-file: "examples/node/package.json"
+                  # cache-dependency-path: '**/package-lock.json'
+
+            - name: Install Example Deps
+              run: "npm install"
+              working-directory: "examples/node"
+
+            - name: Check Syntax
+              run: "node --check app.js"
+              working-directory: "examples/node"
+
+            - name: Typecheck
+              run: "npx tsc"
+              working-directory: "examples/node"
+
    workflow_lint:
        name: "Workflow Lint"
        runs-on: ubuntu-24.04
@@ -116,7 +116,7 @@ jobs:
        steps:
            - name: Skip SonarCloud on merge queues
              if: env.ENABLE_COVERAGE == 'false'
-              uses: guibranco/github-status-action-v2@66088c44e212a906c32a047529a213d81809ec1c
+              uses: guibranco/github-status-action-v2@119b3320db3f04d89e91df840844b92d57ce3468
              with:
                  authToken: ${{ secrets.GITHUB_TOKEN }}
                  state: success
@@ -0,0 +1,20 @@
+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: 100
+                  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,127 @@
+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
+
+* Deprecate `MatrixClient.login` and replace with `loginRequest` ([#4632](https://github.com/matrix-org/matrix-js-sdk/pull/4632)). Contributed by @richvdh.
+* Use `SyncCryptoCallback` api instead of legacy crypto in sliding sync ([#4624](https://github.com/matrix-org/matrix-js-sdk/pull/4624)). Contributed by @florianduros.
+* Distinguish room state and timeline events in embedded clients ([#4574](https://github.com/matrix-org/matrix-js-sdk/pull/4574)). Contributed by @robintown.
+* Allow setting default secret storage key id to null ([#4615](https://github.com/matrix-org/matrix-js-sdk/pull/4615)). Contributed by @florianduros.
+* Add authenticated media to getAvatarUrl in room and room-member models ([#4616](https://github.com/matrix-org/matrix-js-sdk/pull/4616)). Contributed by @m004.
+* Send MSC3981 'recurse' param on `/relations` endpoint on Matrix 1.10 servers ([#4023](https://github.com/matrix-org/matrix-js-sdk/pull/4023)). Contributed by @dbkr.
+
+## 🐛 Bug Fixes
+
+* [Backport staging] Revert "Distinguish room state and timeline events in embedded clients (#4574)" ([#4657](https://github.com/matrix-org/matrix-js-sdk/pull/4657)). Contributed by @RiotRobot.
+* Change randomString et al to be secure ([#4621](https://github.com/matrix-org/matrix-js-sdk/pull/4621)). Contributed by @dbkr.
+* Fix issue with sentinels being incorrect on m.room.member events ([#4609](https://github.com/matrix-org/matrix-js-sdk/pull/4609)). Contributed by @t3chguy.
+
+
+Changes in [36.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v36.0.0) (2025-01-14)
+==================================================================================================
+## 🚨 BREAKING CHANGES
+
+* Remove support for "legacy" MSC3898 group calling in MatrixRTCSession and CallMembership ([#4583](https://github.com/matrix-org/matrix-js-sdk/pull/4583)). Contributed by @toger5.
+
+## ✨ Features
+
+* MatrixRTC: Implement expiry logic for CallMembership and additional test coverage ([#4587](https://github.com/matrix-org/matrix-js-sdk/pull/4587)). Contributed by @toger5.
+
+## 🐛 Bug Fixes
+
+* Don't retry on 4xx responses ([#4601](https://github.com/matrix-org/matrix-js-sdk/pull/4601)). Contributed by @dbkr.
+* Upgrade matrix-sdk-crypto-wasm to 12.1.0 ([#4596](https://github.com/matrix-org/matrix-js-sdk/pull/4596)). Contributed by @andybalaam.
+* Avoid key prompts when resetting crypto ([#4586](https://github.com/matrix-org/matrix-js-sdk/pull/4586)). Contributed by @dbkr.
+* Handle when aud OIDC claim is an Array ([#4584](https://github.com/matrix-org/matrix-js-sdk/pull/4584)). Contributed by @liamdiprose.
+* Save the key backup key to 4S during `bootstrapSecretStorage ` ([#4542](https://github.com/matrix-org/matrix-js-sdk/pull/4542)). Contributed by @dbkr.
+* Only re-prepare MatrixrRTC delayed disconnection event on 404  ([#4575](https://github.com/matrix-org/matrix-js-sdk/pull/4575)). Contributed by @toger5.
+
+
+Changes in [35.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v35.1.0) (2024-12-18)
+==================================================================================================
+This release updates matrix-sdk-crypto-wasm to fix a bug which could prevent loading stored crypto state from storage.
+
+## 🐛 Bug Fixes
+
+* Upgrade matrix-sdk-crypto-wasm to 1.11.0 ([#4593](https://github.com/matrix-org/matrix-js-sdk/pull/4593)).
+
+
+Changes in [35.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v35.0.0) (2024-12-17)
+==================================================================================================
+## 🚨 BREAKING CHANGES
+
+This release contains several breaking changes which will need code changes in your app. Most notably, `initCrypto()`
+no longer exists and has been moved to `initLegacyCrypto()` in preparation for the eventual removal of Olm. You can
+continue to use legacy Olm crypto for now by calling `initLegacyCrypto()` instead.
+
+You may also need to make further changes if you use more advanced APIs. See the individual PRs (listed in order of size of change) for specific APIs changed and how to migrate.
+
+* Rename `MatrixClient.initCrypto` into `MatrixClient.initLegacyCrypto` ([#4567](https://github.com/matrix-org/matrix-js-sdk/pull/4567)). Contributed by @florianduros.
+* Support MSC4222 `state_after` ([#4487](https://github.com/matrix-org/matrix-js-sdk/pull/4487)). Contributed by @dbkr.
+* Avoid use of Buffer as it does not exist in the Web natively ([#4569](https://github.com/matrix-org/matrix-js-sdk/pull/4569)). Contributed by @t3chguy.
+
+## 🦖 Deprecations
+
+* Deprecate remaining legacy functions and move `CryptoEvent.LegacyCryptoStoreMigrationProgress` handler ([#4560](https://github.com/matrix-org/matrix-js-sdk/pull/4560)). Contributed by @florianduros.
+
+## ✨ Features
+
+* Rename `MatrixClient.initCrypto` into `MatrixClient.initLegacyCrypto` ([#4567](https://github.com/matrix-org/matrix-js-sdk/pull/4567)). Contributed by @florianduros.
+* Avoid use of Buffer as it does not exist in the Web natively ([#4569](https://github.com/matrix-org/matrix-js-sdk/pull/4569)). Contributed by @t3chguy.
+* Re-send MatrixRTC media encryption keys for a new joiner even if a rotation is in progress ([#4561](https://github.com/matrix-org/matrix-js-sdk/pull/4561)). Contributed by @hughns.
+* Support MSC4222 `state_after` ([#4487](https://github.com/matrix-org/matrix-js-sdk/pull/4487)). Contributed by @dbkr.
+* Revert "Fix room state being updated with old (now overwritten) state and emitting for those updates. (#4242)" ([#4532](https://github.com/matrix-org/matrix-js-sdk/pull/4532)). Contributed by @toger5.
+
+## 🐛 Bug Fixes
+
+* Fix age field check in event echo processing ([#3635](https://github.com/matrix-org/matrix-js-sdk/pull/3635)). Contributed by @stas-demydiuk.
+
+
 Changes in [34.13.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v34.13.0) (2024-12-03)
 ====================================================================================================
 ## 🦖 Deprecations
@@ -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.
@@ -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.
@@ -94,20 +94,14 @@ rl.on("line", function (line) {
            );
        } else if (line.indexOf("/file ") === 0) {
            var filename = line.split(" ")[1].trim();
-            var stream = fs.createReadStream(filename);
-            matrixClient
-                .uploadContent({
-                    stream: stream,
-                    name: filename,
-                })
-                .then(function (url) {
-                    var content = {
-                        msgtype: MsgType.File,
-                        body: filename,
-                        url: JSON.parse(url).content_uri,
-                    };
-                    matrixClient.sendMessage(viewingRoom.roomId, content);
+            let buffer = fs.readFileSync("./your_file_name");
+            matrixClient.uploadContent(new Blob([buffer])).then(function (response) {
+                matrixClient.sendMessage(viewingRoom.roomId, {
+                    msgtype: MsgType.File,
+                    body: filename,
+                    url: response.content_uri,
                });
+            });
        } else {
            matrixClient.sendTextMessage(viewingRoom.roomId, line).finally(function () {
                printMessages();
@@ -167,7 +161,7 @@ matrixClient.on(RoomEvent.Timeline, function (event, room, toStartOfTimeline) {
    if (toStartOfTimeline) {
        return; // don't print paginated results
    }
-    if (!viewingRoom || viewingRoom.roomId !== room.roomId) {
+    if (!viewingRoom || viewingRoom.roomId !== room?.roomId) {
        return; // not viewing a room or viewing the wrong room.
    }
    printLine(event);
@@ -386,7 +380,7 @@ function print(str, formatter) {
        }
        console.log.apply(console.log, newArgs);
    } else {
-        console.log.apply(console.log, arguments);
+        console.log.apply(console.log, [...arguments]);
    }
 }

@@ -9,5 +9,12 @@
    "dependencies": {
        "cli-color": "^1.0.0",
        "matrix-js-sdk": "^34.5.0"
+    },
+    "devDependencies": {
+        "@types/cli-color": "^2.0.6",
+        "typescript": "^5.6.2"
+    },
+    "engines": {
+        "node": ">=20.0.0"
    }
 }
@@ -0,0 +1,14 @@
+{
+    "compilerOptions": {
+        "target": "es2022",
+        "module": "commonjs",
+        "esModuleInterop": true,
+        "noImplicitAny": false,
+        "noEmit": true,
+        "skipLibCheck": true,
+        "allowJs": true,
+        "checkJs": true,
+        "strict": true
+    },
+    "include": ["app.js"]
+}
@@ -6,11 +6,21 @@ export default {
        "src/types.ts",
        "src/browser-index.ts",
        "src/indexeddb-worker.ts",
+        "src/crypto-api/index.ts",
+        "src/testing.ts",
+        "src/matrix.ts",
        "scripts/**",
        "spec/**",
-        "release.sh",
-        // For now, we include all source files as entrypoints as we have been bad about gutwrenched imports
-        "src/**",
+        // XXX: these look entirely unused
+        "src/crypto/aes.ts",
+        "src/crypto/crypto.ts",
+        "src/crypto/recoverykey.ts",
+        // XXX: these should be re-exported by one of the supported exports
+        "src/matrixrtc/index.ts",
+        "src/sliding-sync.ts",
+        "src/webrtc/groupCall.ts",
+        "src/webrtc/stats/media/mediaTrackStats.ts",
+        "src/rendezvous/RendezvousChannel.ts",
    ],
    project: ["**/*.{js,ts}"],
    ignore: ["examples/**"],
@@ -33,4 +43,6 @@ export default {
        "dist",
    ],
    ignoreExportsUsedInFile: true,
+    includeEntryExports: false,
+    exclude: ["enumMembers"],
 } satisfies KnipConfig;
@@ -1,6 +1,6 @@
 {
    "name": "matrix-js-sdk",
-    "version": "35.0.0-rc.0",
+    "version": "37.0.0",
    "description": "Matrix Client-Server SDK for Javascript",
    "engines": {
        "node": ">=20.0.0"
@@ -50,7 +50,7 @@
    ],
    "dependencies": {
        "@babel/runtime": "^7.12.5",
-        "@matrix-org/matrix-sdk-crypto-wasm": "^11.0.0",
+        "@matrix-org/matrix-sdk-crypto-wasm": "^13.0.0",
        "@matrix-org/olm": "3.2.15",
        "another-json": "^0.2.0",
        "bs58": "^6.0.0",
@@ -81,7 +81,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",
+        "@stylistic/eslint-plugin": "^3.0.0",
        "@types/bs58": "^4.0.1",
        "@types/content-type": "^1.1.5",
        "@types/debug": "^4.1.7",
@@ -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-config-prettier": "^10.0.0",
        "eslint-import-resolver-typescript": "^3.5.1",
        "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,7 +117,7 @@
        "lint-staged": "^15.0.2",
        "matrix-mock-request": "^2.5.0",
        "node-fetch": "^2.7.0",
-        "prettier": "3.4.1",
+        "prettier": "3.4.2",
        "rimraf": "^6.0.0",
        "ts-node": "^10.9.2",
        "typedoc": "^0.27.0",
@@ -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,11 +17,13 @@ limitations under the License.
 import "fake-indexeddb/auto";
 import fetchMock from "fetch-mock-jest";

-import { createClient, ClientEvent, MatrixClient, MatrixEvent } from "../../../src";
-import { RustCrypto } from "../../../src/rust-crypto/rust-crypto";
-import { AddSecretStorageKeyOpts } from "../../../src/secret-storage";
+import { ClientEvent, createClient, type MatrixClient, MatrixEvent } from "../../../src";
+import { CryptoEvent } from "../../../src/crypto-api/index";
+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";

 describe("Device dehydration", () => {
    it("should rehydrate and dehydrate a device", async () => {
@@ -40,6 +42,12 @@ describe("Device dehydration", () => {

        await initializeSecretStorage(matrixClient, "@alice:localhost", "http://test.server");

+        const creationEventCounter = new EventCounter(matrixClient, CryptoEvent.DehydratedDeviceCreated);
+        const dehydrationKeyCachedEventCounter = new EventCounter(matrixClient, CryptoEvent.DehydrationKeyCached);
+        const rehydrationStartedCounter = new EventCounter(matrixClient, CryptoEvent.RehydrationStarted);
+        const rehydrationCompletedCounter = new EventCounter(matrixClient, CryptoEvent.RehydrationCompleted);
+        const rehydrationProgressCounter = new EventCounter(matrixClient, CryptoEvent.RehydrationProgress);
+
        // count the number of times the dehydration key gets set
        let setDehydrationCount = 0;
        matrixClient.on(ClientEvent.AccountData, (event: MatrixEvent) => {
@@ -74,6 +82,8 @@ describe("Device dehydration", () => {
        await crypto.startDehydration();

        expect(dehydrationCount).toEqual(1);
+        expect(creationEventCounter.counter).toEqual(1);
+        expect(dehydrationKeyCachedEventCounter.counter).toEqual(1);

        // a week later, we should have created another dehydrated device
        const dehydrationPromise = new Promise<void>((resolve, reject) => {
@@ -81,7 +91,10 @@ describe("Device dehydration", () => {
        });
        jest.advanceTimersByTime(7 * 24 * 60 * 60 * 1000);
        await dehydrationPromise;
+
+        expect(dehydrationKeyCachedEventCounter.counter).toEqual(1);
        expect(dehydrationCount).toEqual(2);
+        expect(creationEventCounter.counter).toEqual(2);

        // restart dehydration -- rehydrate the device that we created above,
        // and create a new dehydrated device.  We also set `createNewKey`, so
@@ -113,6 +126,39 @@ describe("Device dehydration", () => {
        expect(setDehydrationCount).toEqual(2);
        expect(eventsResponse.mock.calls).toHaveLength(2);

+        expect(rehydrationStartedCounter.counter).toEqual(1);
+        expect(rehydrationCompletedCounter.counter).toEqual(1);
+        expect(creationEventCounter.counter).toEqual(3);
+        expect(rehydrationProgressCounter.counter).toEqual(1);
+        expect(dehydrationKeyCachedEventCounter.counter).toEqual(2);
+
+        // test that if we get an error when we try to rotate, it emits an event
+        fetchMock.put("path:/_matrix/client/unstable/org.matrix.msc3814.v1/dehydrated_device", {
+            status: 500,
+            body: {
+                errcode: "M_UNKNOWN",
+                error: "Unknown error",
+            },
+        });
+        const rotationErrorEventPromise = emitPromise(matrixClient, CryptoEvent.DehydratedDeviceRotationError);
+        jest.advanceTimersByTime(7 * 24 * 60 * 60 * 1000);
+        await rotationErrorEventPromise;
+
+        // Restart dehydration, but return an error for GET /dehydrated_device so that rehydration fails.
+        fetchMock.get("path:/_matrix/client/unstable/org.matrix.msc3814.v1/dehydrated_device", {
+            status: 500,
+            body: {
+                errcode: "M_UNKNOWN",
+                error: "Unknown error",
+            },
+        });
+        fetchMock.put("path:/_matrix/client/unstable/org.matrix.msc3814.v1/dehydrated_device", (_, opts) => {
+            return {};
+        });
+        const rehydrationErrorEventPromise = emitPromise(matrixClient, CryptoEvent.RehydrationError);
+        await crypto.startDehydration(true);
+        await rehydrationErrorEventPromise;
+
        matrixClient.stopClient();
    });
 });
@@ -172,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;

@@ -91,7 +84,7 @@ function mockUploadEmitter(
                    },
                };
            }
-            const uploadPayload: KeyBackup = JSON.parse(request.body?.toString() ?? "{}");
+            const uploadPayload: KeyBackup = JSON.parse((request.body as string) ?? "{}");
            let count = 0;
            for (const [roomId, value] of Object.entries(uploadPayload.rooms)) {
                for (const sessionId of Object.keys(value.sessions)) {
@@ -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";

@@ -644,126 +642,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 +1506,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 +2032,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,9 +45,16 @@ 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" {
+    interface AccountDataEvents {
+        a: {};
+        b: {};
+    }
+}
+
 describe("MatrixClient syncing", () => {
    const selfUserId = "@alice:localhost";
    const selfAccessToken = "aseukfgwef";
@@ -112,7 +117,7 @@ describe("MatrixClient syncing", () => {
        });

        it("should emit RoomEvent.MyMembership for invite->leave->invite cycles", async () => {
-            await client!.initLegacyCrypto();
+            await client!.initRustCrypto();

            const roomId = "!cycles:example.org";

@@ -227,7 +232,7 @@ describe("MatrixClient syncing", () => {
        });

        it("should emit RoomEvent.MyMembership for knock->leave->knock cycles", async () => {
-            await client!.initLegacyCrypto();
+            await client!.initRustCrypto();

            const roomId = "!cycles:example.org";

@@ -2564,16 +2569,15 @@ 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, {});
        idbHttpBackend.when("GET", "/pushrules/").respond(200, {});
        idbHttpBackend.when("POST", "/filter").respond(200, { filter_id: "a filter id" });

-        await idbClient.initLegacyCrypto();
+        await idbClient.initRustCrypto();

        const roomId = "!invite:example.org";

@@ -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,13 +30,13 @@ import { defer } from "../../../src/utils";
 import {
    ClientPrefix,
    DEVICE_CODE_SCOPE,
-    IHttpOpts,
-    IMyDevice,
-    MatrixClient,
+    type IHttpOpts,
+    type IMyDevice,
+    type MatrixClient,
    MatrixError,
    MatrixHttpApi,
 } from "../../../src";
-import { mockOpenIdConfiguration } from "../../test-utils/oidc";
+import { makeDelegatedAuthConfig } from "../../test-utils/oidc";

 function makeMockClient(opts: { userId: string; deviceId: string; msc4108Enabled: boolean }): MatrixClient {
    const baseUrl = "https://example.com";
@@ -57,7 +57,7 @@ function makeMockClient(opts: { userId: string; deviceId: string; msc4108Enabled
        getDomain: () => "example.com",
        getDevice: jest.fn(),
        getCrypto: jest.fn(() => crypto),
-        getAuthIssuer: jest.fn().mockResolvedValue({ issuer: "https://issuer/" }),
+        getAuthMetadata: jest.fn().mockResolvedValue(makeDelegatedAuthConfig("https://issuer/", [DEVICE_CODE_SCOPE])),
    } as unknown as MatrixClient;
    client.http = new MatrixHttpApi<IHttpOpts & { onlyData: true }>(client, {
        baseUrl: client.baseUrl,
@@ -69,10 +69,6 @@ function makeMockClient(opts: { userId: string; deviceId: string; msc4108Enabled

 describe("MSC4108SignInWithQR", () => {
    beforeEach(() => {
-        fetchMock.get(
-            "https://issuer/.well-known/openid-configuration",
-            mockOpenIdConfiguration("https://issuer/", [DEVICE_CODE_SCOPE]),
-        );
        fetchMock.get("https://issuer/jwks", {
            status: 200,
            headers: {
@@ -15,41 +15,56 @@ 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 { type SyncCryptoCallbacks } from "../../src/common-crypto/CryptoBackend";
+
+declare module "../../src/@types/event" {
+    interface AccountDataEvents {
+        global_test: {};
+        tester: {};
+    }
+}

 describe("SlidingSyncSdk", () => {
    let client: MatrixClient | undefined;
    let httpBackend: MockHttpBackend | undefined;
    let sdk: SlidingSyncSdk | undefined;
    let mockSlidingSync: SlidingSync | undefined;
+    let syncCryptoCallback: SyncCryptoCallbacks | undefined;
    const selfUserId = "@alice:localhost";
    const selfAccessToken = "aseukfgwef";

@@ -119,8 +134,9 @@ describe("SlidingSyncSdk", () => {
        mockSlidingSync = mockifySlidingSync(new SlidingSync("", new Map(), {}, client, 0));
        if (testOpts.withCrypto) {
            httpBackend!.when("GET", "/room_keys/version").respond(404, {});
-            await client!.initLegacyCrypto();
-            syncOpts.cryptoCallbacks = syncOpts.crypto = client!.crypto;
+            await client!.initRustCrypto({ useIndexedDB: false });
+            syncCryptoCallback = client!.getCrypto() as unknown as SyncCryptoCallbacks;
+            syncOpts.cryptoCallbacks = syncCryptoCallback;
        }
        httpBackend!.when("GET", "/_matrix/client/v3/pushrules").respond(200, {});
        sdk = new SlidingSyncSdk(mockSlidingSync, client, testOpts, syncOpts);
@@ -633,13 +649,6 @@ describe("SlidingSyncSdk", () => {
            ext = findExtension("e2ee");
        });

-        afterAll(async () => {
-            // needed else we do some async operations in the background which can cause Jest to whine:
-            // "Cannot log after tests are done. Did you forget to wait for something async in your test?"
-            // Attempted to log "Saving device tracking data null"."
-            client!.crypto!.stop();
-        });
-
        it("gets enabled on the initial request only", () => {
            expect(ext.onRequest(true)).toEqual({
                enabled: true,
@@ -648,28 +657,28 @@ describe("SlidingSyncSdk", () => {
        });

        it("can update device lists", () => {
-            client!.crypto!.processDeviceLists = jest.fn();
+            syncCryptoCallback!.processDeviceLists = jest.fn();
            ext.onResponse({
                device_lists: {
                    changed: ["@alice:localhost"],
                    left: ["@bob:localhost"],
                },
            });
-            expect(client!.crypto!.processDeviceLists).toHaveBeenCalledWith({
+            expect(syncCryptoCallback!.processDeviceLists).toHaveBeenCalledWith({
                changed: ["@alice:localhost"],
                left: ["@bob:localhost"],
            });
        });

        it("can update OTK counts and unused fallback keys", () => {
-            client!.crypto!.processKeyCounts = jest.fn();
+            syncCryptoCallback!.processKeyCounts = jest.fn();
            ext.onResponse({
                device_one_time_keys_count: {
                    signed_curve25519: 42,
                },
                device_unused_fallback_key_types: ["signed_curve25519"],
            });
-            expect(client!.crypto!.processKeyCounts).toHaveBeenCalledWith({ signed_curve25519: 42 }, [
+            expect(syncCryptoCallback!.processKeyCounts).toHaveBeenCalledWith({ signed_curve25519: 42 }, [
                "signed_curve25519",
            ]);
        });
@@ -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.
@@ -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 },
    );
@@ -88,7 +89,7 @@ export function mockSetupMegolmBackupRequests(backupVersion: string): void {
    });

    fetchMock.post("path:/_matrix/client/v3/room_keys/version", (url, request) => {
-        const backupData: KeyBackupInfo = JSON.parse(request.body?.toString() ?? "{}");
+        const backupData: KeyBackupInfo = JSON.parse((request.body as string) ?? "{}");
        backupData.version = backupVersion;
        backupData.count = 0;
        backupData.etag = "zer";
@@ -14,42 +14,4 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { OidcClientConfig, ValidatedIssuerMetadata } from "../../src";
-
-/**
- * Makes a valid OidcClientConfig with minimum valid values
- * @param issuer used as the base for all other urls
- * @returns OidcClientConfig
- */
-export const makeDelegatedAuthConfig = (issuer = "https://auth.org/"): OidcClientConfig => {
-    const metadata = mockOpenIdConfiguration(issuer);
-
-    return {
-        accountManagementEndpoint: issuer + "account",
-        registrationEndpoint: metadata.registration_endpoint,
-        authorizationEndpoint: metadata.authorization_endpoint,
-        tokenEndpoint: metadata.token_endpoint,
-        metadata,
-    };
-};
-
-/**
- * Useful for mocking <issuer>/.well-known/openid-configuration
- * @param issuer used as the base for all other urls
- * @returns ValidatedIssuerMetadata
- */
-export const mockOpenIdConfiguration = (
-    issuer = "https://auth.org/",
-    additionalGrantTypes: string[] = [],
-): ValidatedIssuerMetadata => ({
-    issuer,
-    revocation_endpoint: issuer + "revoke",
-    token_endpoint: issuer + "token",
-    authorization_endpoint: issuer + "auth",
-    registration_endpoint: issuer + "registration",
-    device_authorization_endpoint: issuer + "device",
-    jwks_uri: issuer + "jwks",
-    response_types_supported: ["code"],
-    grant_types_supported: ["authorization_code", "refresh_token", ...additionalGrantTypes],
-    code_challenge_methods_supported: ["S256"],
-});
+export { makeDelegatedAuthConfig, mockOpenIdConfiguration } from "../../src/testing.ts";
@@ -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,20 +558,21 @@ 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));

+/**
+ * Counts the number of times that an event was emitted.
+ */
+export class EventCounter {
+    public counter;
+    constructor(emitter: EventEmitter, event: string) {
+        this.counter = 0;
+        emitter.on(event, () => {
+            this.counter++;
+        });
+    }
+}
+
 /**
 * Advance the fake timers in a loop until the given promise resolves or rejects.
 *
@@ -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";

@@ -207,6 +207,17 @@ describe("Topic content helpers", () => {
                ],
            });
        });
+
+        it("creates an empty event when the topic is falsey", () => {
+            expect(makeTopicContent(undefined)).toEqual({
+                topic: undefined,
+                [M_TOPIC.name]: [],
+            });
+            expect(makeTopicContent(null)).toEqual({
+                topic: null,
+                [M_TOPIC.name]: [],
+            });
+        });
    });

    describe("parseTopicContent()", () => {
@@ -257,5 +268,26 @@ describe("Topic content helpers", () => {
                html: "<b>pizza</b>",
            });
        });
+
+        it("parses legacy event content", () => {
+            expect(
+                parseTopicContent({
+                    topic: "pizza",
+                }),
+            ).toEqual({
+                text: "pizza",
+            });
+        });
+
+        it("uses legacy event content when new topic key is invalid", () => {
+            expect(
+                parseTopicContent({
+                    "topic": "pizza",
+                    "m.topic": {} as any,
+                }),
+            ).toEqual({
+                text: "pizza",
+            });
+        });
    });
 });
@@ -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,690 +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";
-
-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;
-    };
-}
-
-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 = {
@@ -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[] = [];
@@ -23,6 +23,7 @@ import {
    EventTimelineSet,
    EventType,
    Filter,
+    KnownMembership,
    MatrixClient,
    MatrixEvent,
    MatrixEventEvent,
@@ -138,6 +139,31 @@ describe("EventTimelineSet", () => {
            expect(eventsInLiveTimeline.length).toStrictEqual(1);
            expect(eventsInLiveTimeline[0]).toStrictEqual(duplicateMessageEvent);
        });
+
+        it("should set event.target after applying the membership state update", () => {
+            const eventTimelineSet = room.getUnfilteredTimelineSet();
+
+            const ev1 = utils.mkMembership({
+                room: roomId,
+                mship: KnownMembership.Invite,
+                user: "@sender:server",
+                skey: userA,
+                event: true,
+            });
+            const ev2 = utils.mkMembership({
+                room: roomId,
+                mship: KnownMembership.Join,
+                user: userA,
+                skey: userA,
+                name: "This is my displayname",
+                event: true,
+            });
+
+            eventTimelineSet.addLiveEvent(ev1, { addToState: true });
+            expect(ev1.target?.name).toBe(userA);
+            eventTimelineSet.addLiveEvent(ev2, { addToState: true });
+            expect(ev2.target?.name).toBe("This is my displayname");
+        });
    });

    describe("addEventToTimeline", () => {
@@ -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,22 @@ 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,
    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";
@@ -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] };
@@ -15,12 +15,12 @@ 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";
 import { sleep } from "../../src/utils";
-import { randomString } from "../../src/randomstring";
+import { secureRandomString } from "../../src/randomstring";

 // Trivial client object to test interactive auth
 // (we do not need TestClient here)
@@ -502,7 +502,7 @@ describe("InteractiveAuth", () => {
            const doRequest = jest.fn();
            const stateUpdated = jest.fn();
            const requestEmailToken = jest.fn();
-            const sid = randomString(24);
+            const sid = secureRandomString(24);
            requestEmailToken.mockImplementation(() => sleep(500, { sid }));

            const ia = new InteractiveAuth({
@@ -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,10 +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 {
@@ -30,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";
@@ -42,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,
@@ -67,15 +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();

@@ -94,6 +102,12 @@ function convertQueryDictToMap(queryDict?: QueryDict): Map<string, string> {
    return new Map(Object.entries(queryDict).map(([k, v]) => [k, String(v)]));
 }

+declare module "../../src/@types/event" {
+    interface AccountDataEvents {
+        "im.vector.test": {};
+    }
+}
+
 type HttpLookup = {
    method: string;
    path: string;
@@ -114,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());
@@ -154,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;
@@ -259,13 +290,17 @@ describe("MatrixClient", function () {

            if (next.error) {
                // eslint-disable-next-line
-                return Promise.reject({
-                    errcode: (<MatrixError>next.error).errcode,
-                    httpStatus: (<MatrixError>next.error).httpStatus,
-                    name: (<MatrixError>next.error).errcode,
-                    message: "Expected testing error",
-                    data: next.error,
-                });
+                return Promise.reject(
+                    new MatrixError(
+                        {
+                            errcode: (<MatrixError>next.error).errcode,
+                            name: (<MatrixError>next.error).errcode,
+                            message: "Expected testing error",
+                            data: next.error,
+                        },
+                        (<MatrixError>next.error).httpStatus,
+                    ),
+                );
            }
            return Promise.resolve(next.data);
        }
@@ -1178,7 +1213,7 @@ describe("MatrixClient", function () {
                        type: EventType.RoomEncryption,
                        state_key: "",
                        content: {
-                            algorithm: MEGOLM_ALGORITHM,
+                            algorithm: "m.megolm.v1.aes-sha2",
                        },
                    },
                ],
@@ -1904,7 +1939,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 () => {
@@ -1924,8 +1959,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() {
@@ -2244,7 +2279,7 @@ describe("MatrixClient", function () {
    });

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

@@ -2311,21 +2346,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`.
@@ -2659,10 +2679,164 @@ 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);
+
+            // 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, 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 = {
@@ -2671,17 +2845,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 () => {
@@ -2690,34 +2864,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("{}");
        });
    });

@@ -3187,24 +3370,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);
@@ -3212,60 +3377,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 = {
@@ -3483,6 +3594,63 @@ describe("MatrixClient", function () {
        });
    });

+    describe("getAuthMetadata", () => {
+        beforeEach(() => {
+            fetchMock.mockReset();
+            // This request is made by oidc-client-ts so is not intercepted by httpLookups
+            fetchMock.get("https://auth.org/jwks", {
+                status: 200,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                keys: [],
+            });
+        });
+
+        it("should use unstable prefix", async () => {
+            const metadata = mockOpenIdConfiguration();
+            httpLookups = [
+                {
+                    method: "GET",
+                    path: `/auth_metadata`,
+                    data: metadata,
+                    prefix: "/_matrix/client/unstable/org.matrix.msc2965",
+                },
+            ];
+
+            await expect(client.getAuthMetadata()).resolves.toEqual({
+                ...metadata,
+                signingKeys: [],
+            });
+            expect(httpLookups.length).toEqual(0);
+        });
+
+        it("should fall back to auth_issuer + openid-configuration", async () => {
+            const metadata = mockOpenIdConfiguration();
+            httpLookups = [
+                {
+                    method: "GET",
+                    path: `/auth_metadata`,
+                    error: new MatrixError({ errcode: "M_UNRECOGNIZED" }, 404),
+                    prefix: "/_matrix/client/unstable/org.matrix.msc2965",
+                },
+                {
+                    method: "GET",
+                    path: `/auth_issuer`,
+                    data: { issuer: metadata.issuer },
+                    prefix: "/_matrix/client/unstable/org.matrix.msc2965",
+                },
+            ];
+            fetchMock.get("https://auth.org/.well-known/openid-configuration", metadata);
+
+            await expect(client.getAuthMetadata()).resolves.toEqual({
+                ...metadata,
+                signingKeys: [],
+            });
+            expect(httpLookups.length).toEqual(0);
+        });
+    });
+
    describe("identityHashedLookup", () => {
        it("should return hashed lookup results", async () => {
            const ID_ACCESS_TOKEN = "hello_id_server_please_let_me_make_a_request";
@@ -14,8 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { MatrixEvent } from "../../../src";
-import { CallMembership, CallMembershipDataLegacy, SessionMembershipData } 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 {
    return {
@@ -25,91 +30,15 @@ function makeMockEvent(originTs = 0): MatrixEvent {
 }

 describe("CallMembership", () => {
-    describe("CallMembershipDataLegacy", () => {
-        const membershipTemplate: CallMembershipDataLegacy = {
-            call_id: "",
-            scope: "m.room",
-            application: "m.call",
-            device_id: "AAAAAAA",
-            expires: 5000,
-            membershipID: "bloop",
-            foci_active: [{ type: "livekit" }],
-        };
-        it("rejects membership with no expiry and no expires_ts", () => {
-            expect(() => {
-                new CallMembership(
-                    makeMockEvent(),
-                    Object.assign({}, membershipTemplate, { expires: undefined, expires_ts: undefined }),
-                );
-            }).toThrow();
-        });
-
-        it("rejects membership with no device_id", () => {
-            expect(() => {
-                new CallMembership(makeMockEvent(), Object.assign({}, membershipTemplate, { device_id: undefined }));
-            }).toThrow();
-        });
-
-        it("rejects membership with no call_id", () => {
-            expect(() => {
-                new CallMembership(makeMockEvent(), Object.assign({}, membershipTemplate, { call_id: undefined }));
-            }).toThrow();
-        });
-
-        it("allow membership with no scope", () => {
-            expect(() => {
-                new CallMembership(makeMockEvent(), Object.assign({}, membershipTemplate, { scope: undefined }));
-            }).not.toThrow();
-        });
-        it("rejects with malformatted expires_ts", () => {
-            expect(() => {
-                new CallMembership(makeMockEvent(), Object.assign({}, membershipTemplate, { expires_ts: "string" }));
-            }).toThrow();
-        });
-        it("rejects with malformatted expires", () => {
-            expect(() => {
-                new CallMembership(makeMockEvent(), Object.assign({}, membershipTemplate, { expires: "string" }));
-            }).toThrow();
-        });
-
-        it("uses event timestamp if no created_ts", () => {
-            const membership = new CallMembership(makeMockEvent(12345), membershipTemplate);
-            expect(membership.createdTs()).toEqual(12345);
-        });
-
-        it("uses created_ts if present", () => {
-            const membership = new CallMembership(
-                makeMockEvent(12345),
-                Object.assign({}, membershipTemplate, { created_ts: 67890 }),
-            );
-            expect(membership.createdTs()).toEqual(67890);
-        });
-
-        it("computes absolute expiry time based on expires", () => {
-            const membership = new CallMembership(makeMockEvent(1000), membershipTemplate);
-            expect(membership.getAbsoluteExpiry()).toEqual(5000 + 1000);
-        });
-
-        it("computes absolute expiry time based on expires_ts", () => {
-            const membership = new CallMembership(
-                makeMockEvent(1000),
-                Object.assign({}, membershipTemplate, { expires_ts: 6000 }),
-            );
-            expect(membership.getAbsoluteExpiry()).toEqual(5000 + 1000);
-        });
-
-        it("returns preferred foci", () => {
-            const fakeEvent = makeMockEvent();
-            const mockFocus = { type: "this_is_a_mock_focus" };
-            const membership = new CallMembership(
-                fakeEvent,
-                Object.assign({}, membershipTemplate, { foci_active: [mockFocus] }),
-            );
-            expect(membership.getPreferredFoci()).toEqual([mockFocus]);
-        });
-    });
-
    describe("SessionMembershipData", () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+        });
+
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+
        const membershipTemplate: SessionMembershipData = {
            call_id: "",
            scope: "m.room",
@@ -152,9 +81,14 @@ describe("CallMembership", () => {

        it("considers memberships unexpired if local age low enough", () => {
            const fakeEvent = makeMockEvent(1000);
-            fakeEvent.getLocalAge = jest.fn().mockReturnValue(3000);
-            const membership = new CallMembership(fakeEvent, membershipTemplate);
-            expect(membership.isExpired()).toEqual(false);
+            fakeEvent.getTs = jest.fn().mockReturnValue(Date.now() - (DEFAULT_EXPIRE_DURATION - 1));
+            expect(new CallMembership(fakeEvent, membershipTemplate).isExpired()).toEqual(false);
+        });
+
+        it("considers memberships expired if local age large enough", () => {
+            const fakeEvent = makeMockEvent(1000);
+            fakeEvent.getTs = jest.fn().mockReturnValue(Date.now() - (DEFAULT_EXPIRE_DURATION + 1));
+            expect(new CallMembership(fakeEvent, membershipTemplate).isExpired()).toEqual(true);
        });

        it("returns preferred foci", () => {
@@ -171,15 +105,6 @@ describe("CallMembership", () => {
    describe("expiry calculation", () => {
        let fakeEvent: MatrixEvent;
        let membership: CallMembership;
-        const membershipTemplate: CallMembershipDataLegacy = {
-            call_id: "",
-            scope: "m.room",
-            application: "m.call",
-            device_id: "AAAAAAA",
-            expires: 5000,
-            membershipID: "bloop",
-            foci_active: [{ type: "livekit" }],
-        };

        beforeEach(() => {
            // server origin timestamp for this event is 1000
@@ -193,24 +118,10 @@ describe("CallMembership", () => {
            jest.useRealTimers();
        });

-        it("converts expiry time into local clock", () => {
-            // our clock would have been at 2000 at the creation time (our clock at event receive time - age)
-            // (ie. the local clock is 1 second ahead of the servers' clocks)
-            fakeEvent.localTimestamp = 2000;
-
-            // for simplicity's sake, we say that the event's age is zero
-            fakeEvent.getLocalAge = jest.fn().mockReturnValue(0);
-
-            // for sanity's sake, make sure the server-relative expiry time is what we expect
-            expect(membership.getAbsoluteExpiry()).toEqual(6000);
-            // therefore the expiry time converted to our clock should be 1 second later
-            expect(membership.getLocalExpiry()).toEqual(7000);
-        });
-
        it("calculates time until expiry", () => {
            jest.setSystemTime(2000);
            // should be using absolute expiry time
-            expect(membership.getMsUntilExpiry()).toEqual(4000);
+            expect(membership.getMsUntilExpiry()).toEqual(DEFAULT_EXPIRE_DURATION - 1000);
        });
    });
 });
@@ -14,27 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { encodeBase64, EventTimeline, EventType, MatrixClient, MatrixError, MatrixEvent, Room } from "../../../src";
+import { encodeBase64, EventType, MatrixClient, MatrixError, type MatrixEvent, type Room } from "../../../src";
 import { KnownMembership } from "../../../src/@types/membership";
-import {
-    CallMembershipData,
-    CallMembershipDataLegacy,
-    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 { randomString } from "../../../src/randomstring";
-import { makeMockRoom, makeMockRoomState, mockRTCEvent } from "./mocks";
-
-const membershipTemplate: CallMembershipData = {
-    call_id: "",
-    scope: "m.room",
-    application: "m.call",
-    device_id: "AAAAAAA",
-    expires: 60 * 60 * 1000,
-    membershipID: "bloop",
-    foci_active: [{ type: "livekit", livekit_service_url: "https://lk.url" }],
-};
+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" };

@@ -59,7 +46,7 @@ describe("MatrixRTCSession", () => {

    describe("roomSessionForRoom", () => {
        it("creates a room-scoped session from room state", () => {
-            const mockRoom = makeMockRoom([membershipTemplate]);
+            const mockRoom = makeMockRoom(membershipTemplate);

            sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
            expect(sess?.memberships.length).toEqual(1);
@@ -67,7 +54,6 @@ describe("MatrixRTCSession", () => {
            expect(sess?.memberships[0].scope).toEqual("m.room");
            expect(sess?.memberships[0].application).toEqual("m.call");
            expect(sess?.memberships[0].deviceId).toEqual("AAAAAAA");
-            expect(sess?.memberships[0].membershipID).toEqual("bloop");
            expect(sess?.memberships[0].isExpired()).toEqual(false);
            expect(sess?.callId).toEqual("");
        });
@@ -87,7 +73,7 @@ describe("MatrixRTCSession", () => {
        });

        it("ignores memberships events of members not in the room", () => {
-            const mockRoom = makeMockRoom([membershipTemplate]);
+            const mockRoom = makeMockRoom(membershipTemplate);
            mockRoom.hasMembershipState = (state) => state === KnownMembership.Join;
            sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
            expect(sess?.memberships.length).toEqual(0);
@@ -112,7 +98,7 @@ describe("MatrixRTCSession", () => {
        });

        it("safely ignores events with no memberships section", () => {
-            const roomId = randomString(8);
+            const roomId = secureRandomString(8);
            const event = {
                getType: jest.fn().mockReturnValue(EventType.GroupCallMemberPrefix),
                getContent: jest.fn().mockReturnValue({}),
@@ -147,7 +133,7 @@ describe("MatrixRTCSession", () => {
        });

        it("safely ignores events with junk memberships section", () => {
-            const roomId = randomString(8);
+            const roomId = secureRandomString(8);
            const event = {
                getType: jest.fn().mockReturnValue(EventType.GroupCallMemberPrefix),
                getContent: jest.fn().mockReturnValue({ memberships: ["i am a fish"] }),
@@ -181,14 +167,6 @@ describe("MatrixRTCSession", () => {
            expect(sess.memberships).toHaveLength(0);
        });

-        it("ignores memberships with no expires_ts", () => {
-            const expiredMembership = Object.assign({}, membershipTemplate);
-            (expiredMembership.expires as number | undefined) = undefined;
-            const mockRoom = makeMockRoom([expiredMembership]);
-            sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
-            expect(sess.memberships).toHaveLength(0);
-        });
-
        it("ignores memberships with no device_id", () => {
            const testMembership = Object.assign({}, membershipTemplate);
            (testMembership.device_id as string | undefined) = undefined;
@@ -224,23 +202,7 @@ describe("MatrixRTCSession", () => {

    describe("updateCallMembershipEvent", () => {
        const mockFocus = { type: "livekit", livekit_service_url: "https://test.org" };
-        const joinSessionConfig = { useLegacyMemberEvents: false };
-
-        const legacyMembershipData: CallMembershipDataLegacy = {
-            call_id: "",
-            scope: "m.room",
-            application: "m.call",
-            device_id: "AAAAAAA_legacy",
-            expires: 60 * 60 * 1000,
-            membershipID: "bloop",
-            foci_active: [mockFocus],
-        };
-
-        const expiredLegacyMembershipData: CallMembershipDataLegacy = {
-            ...legacyMembershipData,
-            device_id: "AAAAAAA_legacy_expired",
-            expires: 0,
-        };
+        const joinSessionConfig = {};

        const sessionMembershipData: SessionMembershipData = {
            call_id: "",
@@ -273,39 +235,20 @@ describe("MatrixRTCSession", () => {
            client._unstable_sendDelayedStateEvent = sendDelayedStateMock;
        });

-        async function testSession(
-            membershipData: CallMembershipData[] | SessionMembershipData,
-            shouldUseLegacy: boolean,
-        ): Promise<void> {
+        async function testSession(membershipData: SessionMembershipData): Promise<void> {
            sess = MatrixRTCSession.roomSessionForRoom(client, makeMockRoom(membershipData));

-            const makeNewLegacyMembershipsMock = jest.spyOn(sess as any, "makeNewLegacyMemberships");
-            const makeNewMembershipMock = jest.spyOn(sess as any, "makeNewMembership");
-
            sess.joinRoomSession([mockFocus], mockFocus, joinSessionConfig);
            await Promise.race([sentStateEvent, new Promise((resolve) => setTimeout(resolve, 500))]);

-            expect(makeNewLegacyMembershipsMock).toHaveBeenCalledTimes(shouldUseLegacy ? 1 : 0);
-            expect(makeNewMembershipMock).toHaveBeenCalledTimes(shouldUseLegacy ? 0 : 1);
+            expect(sendStateEventMock).toHaveBeenCalledTimes(1);

            await Promise.race([sentDelayedState, new Promise((resolve) => setTimeout(resolve, 500))]);
-            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(shouldUseLegacy ? 0 : 1);
+            expect(sendDelayedStateMock).toHaveBeenCalledTimes(1);
        }

-        it("uses legacy events if there are any active legacy calls", async () => {
-            await testSession([expiredLegacyMembershipData, legacyMembershipData, sessionMembershipData], true);
-        });
-
-        it('uses legacy events if a non-legacy call is in a "memberships" array', async () => {
-            await testSession([sessionMembershipData], true);
-        });
-
-        it("uses non-legacy events if all legacy calls are expired", async () => {
-            await testSession([expiredLegacyMembershipData], false);
-        });
-
-        it("uses non-legacy events if there are only non-legacy calls", async () => {
-            await testSession(sessionMembershipData, false);
+        it("sends events", async () => {
+            await testSession(sessionMembershipData);
        });
    });

@@ -326,7 +269,11 @@ describe("MatrixRTCSession", () => {
    });

    describe("getsActiveFocus", () => {
-        const activeFociConfig = { type: "livekit", livekit_service_url: "https://active.url" };
+        const firstPreferredFocus = {
+            type: "livekit",
+            livekit_service_url: "https://active.url",
+            livekit_alias: "!active:active.url",
+        };
        it("gets the correct active focus with oldest_membership", () => {
            jest.useFakeTimers();
            jest.setSystemTime(3000);
@@ -334,7 +281,7 @@ describe("MatrixRTCSession", () => {
                Object.assign({}, membershipTemplate, {
                    device_id: "foo",
                    created_ts: 500,
-                    foci_active: [activeFociConfig],
+                    foci_preferred: [firstPreferredFocus],
                }),
                Object.assign({}, membershipTemplate, { device_id: "old", created_ts: 1000 }),
                Object.assign({}, membershipTemplate, { device_id: "bar", created_ts: 2000 }),
@@ -346,15 +293,15 @@ describe("MatrixRTCSession", () => {
                type: "livekit",
                focus_selection: "oldest_membership",
            });
-            expect(sess.getActiveFocus()).toBe(activeFociConfig);
+            expect(sess.getActiveFocus()).toBe(firstPreferredFocus);
            jest.useRealTimers();
        });
-        it("does not provide focus if the selction method is unknown", () => {
+        it("does not provide focus if the selection method is unknown", () => {
            const mockRoom = makeMockRoom([
                Object.assign({}, membershipTemplate, {
                    device_id: "foo",
                    created_ts: 500,
-                    foci_active: [activeFociConfig],
+                    foci_preferred: [firstPreferredFocus],
                }),
                Object.assign({}, membershipTemplate, { device_id: "old", created_ts: 1000 }),
                Object.assign({}, membershipTemplate, { device_id: "bar", created_ts: 2000 }),
@@ -368,25 +315,6 @@ describe("MatrixRTCSession", () => {
            });
            expect(sess.getActiveFocus()).toBe(undefined);
        });
-        it("gets the correct active focus legacy", () => {
-            jest.useFakeTimers();
-            jest.setSystemTime(3000);
-            const mockRoom = makeMockRoom([
-                Object.assign({}, membershipTemplate, {
-                    device_id: "foo",
-                    created_ts: 500,
-                    foci_active: [activeFociConfig],
-                }),
-                Object.assign({}, membershipTemplate, { device_id: "old", created_ts: 1000 }),
-                Object.assign({}, membershipTemplate, { device_id: "bar", created_ts: 2000 }),
-            ]);
-
-            sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
-
-            sess.joinRoomSession([{ type: "livekit", livekit_service_url: "htts://test.org" }]);
-            expect(sess.getActiveFocus()).toBe(activeFociConfig);
-            jest.useRealTimers();
-        });
    });

    describe("joining", () => {
@@ -394,9 +322,11 @@ 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) => {
@@ -410,12 +340,15 @@ 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 = jest.fn();
+            client._unstable_updateDelayedEvent = updateDelayedEventMock;

            mockRoom = makeMockRoom([]);
            sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
@@ -448,24 +381,28 @@ describe("MatrixRTCSession", () => {
                mockRoom!.roomId,
                EventType.GroupCallMemberPrefix,
                {
-                    memberships: [
-                        {
-                            application: "m.call",
-                            scope: "m.room",
-                            call_id: "",
-                            device_id: "AAAAAAA",
-                            expires: 3600000,
-                            expires_ts: Date.now() + 3600000,
-                            foci_active: [mockFocus],
-
-                            membershipID: expect.stringMatching(".*"),
-                        },
-                    ],
+                    application: "m.call",
+                    scope: "m.room",
+                    call_id: "",
+                    device_id: "AAAAAAA",
+                    expires: DEFAULT_EXPIRE_DURATION,
+                    foci_preferred: [mockFocus],
+                    focus_active: {
+                        focus_selection: "oldest_membership",
+                        type: "livekit",
+                    },
                },
-                "@alice:example.org",
+                "_@alice:example.org_AAAAAAA",
            );
            await Promise.race([sentDelayedState, new Promise((resolve) => realSetTimeout(resolve, 500))]);
-            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(0);
+            // Because we actually want to send the state
+            expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
+            // For checking if the delayed event is still there or got removed while sending the state.
+            expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
+            // For scheduling the delayed event
+            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
+            // This returns no error so we do not check if we reschedule the event again. this is done in another test.
+
            jest.useRealTimers();
        });

@@ -478,28 +415,25 @@ describe("MatrixRTCSession", () => {
                mockRoom!.roomId,
                EventType.GroupCallMemberPrefix,
                {
-                    memberships: [
-                        {
-                            application: "m.call",
-                            scope: "m.room",
-                            call_id: "",
-                            device_id: "AAAAAAA",
-                            expires: 60000,
-                            expires_ts: Date.now() + 60000,
-                            foci_active: [mockFocus],
-
-                            membershipID: expect.stringMatching(".*"),
-                        },
-                    ],
+                    application: "m.call",
+                    scope: "m.room",
+                    call_id: "",
+                    device_id: "AAAAAAA",
+                    expires: 60000,
+                    foci_preferred: [mockFocus],
+                    focus_active: {
+                        focus_selection: "oldest_membership",
+                        type: "livekit",
+                    },
                },
-                "@alice:example.org",
+                "_@alice:example.org_AAAAAAA",
            );
            await Promise.race([sentDelayedState, new Promise((resolve) => realSetTimeout(resolve, 500))]);
-            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(0);
+            expect(client._unstable_sendDelayedStateEvent).toHaveBeenCalledTimes(1);
            jest.useRealTimers();
        });

-        describe("non-legacy calls", () => {
+        describe("calls", () => {
            const activeFocusConfig = { type: "livekit", livekit_service_url: "https://active.url" };
            const activeFocus = { type: "livekit", focus_selection: "oldest_membership" };

@@ -523,6 +457,7 @@ describe("MatrixRTCSession", () => {
                    });
                });

+                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" });
@@ -547,25 +482,18 @@ describe("MatrixRTCSession", () => {
                    });
                });

-                // needed to advance the mock timers properly
-                const scheduledDelayDisconnection = new Promise<void>((resolve) => {
-                    const originalFn: () => void = (sess as any).scheduleDelayDisconnection;
-                    (sess as any).scheduleDelayDisconnection = jest.fn(() => {
-                        originalFn.call(sess);
-                        resolve();
-                    });
-                });
-
                sess!.joinRoomSession([activeFocusConfig], activeFocus, {
-                    useLegacyMemberEvents: false,
                    membershipServerSideExpiryTimeout: 9000,
                });

-                expect(sess).toHaveProperty("membershipServerSideExpiryTimeout", 9000);
                await sendDelayedStateExceedAttempt.then(); // needed to resolve after the send attempt catches
-                expect(sess).toHaveProperty("membershipServerSideExpiryTimeout", 7500);
-
                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
@@ -579,26 +507,29 @@ describe("MatrixRTCSession", () => {
                        application: "m.call",
                        scope: "m.room",
                        call_id: "",
+                        expires: 14400000,
                        device_id: "AAAAAAA",
                        foci_preferred: [activeFocusConfig],
                        focus_active: activeFocus,
                    } satisfies SessionMembershipData,
-                    `${!useOwnedStateEvents ? "_" : ""}@alice:example.org_AAAAAAA`,
+                    userStateKey,
                );
                await sentDelayedState;

                // should have prepared the heartbeat to keep delaying the leave event while still connected
-                await scheduledDelayDisconnection;
-                // should have tried updating the delayed leave to test that it wasn't replaced by own state
+                await updatedDelayedEvent;
                expect(client._unstable_updateDelayedEvent).toHaveBeenCalledTimes(1);
-                // should update delayed disconnect
+
+                // 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 non-legacy call", async () => {
+            it("sends a membership event with session payload when joining a call", async () => {
                await testJoin(false);
            });

@@ -607,133 +538,63 @@ describe("MatrixRTCSession", () => {
            });
        });

-        it("does nothing if join called when already joined", () => {
+        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);
        });
-
-        it("renews membership event before expiry time", async () => {
-            jest.useFakeTimers();
-            let resolveFn: ((_roomId: string, _type: string, val: Record<string, any>) => void) | undefined;
-
-            const eventSentPromise = new Promise<Record<string, any>>((r) => {
-                resolveFn = (_roomId: string, _type: string, val: Record<string, any>) => {
-                    r(val);
-                };
-            });
-            try {
-                const sendStateEventMock = jest.fn().mockImplementation(resolveFn);
-                client.sendStateEvent = sendStateEventMock;
-
-                sess!.joinRoomSession([mockFocus], mockFocus);
-
-                const eventContent = await eventSentPromise;
-
-                jest.setSystemTime(1000);
-                const event = mockRTCEvent(eventContent.memberships, mockRoom.roomId);
-                const getState = mockRoom.getLiveTimeline().getState(EventTimeline.FORWARDS)!;
-                getState.getStateEvents = jest.fn().mockReturnValue(event);
-                getState.events = new Map([
-                    [
-                        event.getType(),
-                        {
-                            size: () => true,
-                            has: (_stateKey: string) => true,
-                            get: (_stateKey: string) => event,
-                            values: () => [event],
-                        } as unknown as Map<string, MatrixEvent>,
-                    ],
-                ]);
-
-                const eventReSentPromise = new Promise<Record<string, any>>((r) => {
-                    resolveFn = (_roomId: string, _type: string, val: Record<string, any>) => {
-                        r(val);
-                    };
-                });
-
-                sendStateEventMock.mockReset().mockImplementation(resolveFn);
-
-                // definitely should have renewed by 1 second before the expiry!
-                const timeElapsed = 60 * 60 * 1000 - 1000;
-                jest.setSystemTime(Date.now() + timeElapsed);
-                jest.advanceTimersByTime(timeElapsed);
-                await eventReSentPromise;
-
-                expect(sendStateEventMock).toHaveBeenCalledWith(
-                    mockRoom.roomId,
-                    EventType.GroupCallMemberPrefix,
-                    {
-                        memberships: [
-                            {
-                                application: "m.call",
-                                scope: "m.room",
-                                call_id: "",
-                                device_id: "AAAAAAA",
-                                expires: 3600000 * 2,
-                                expires_ts: 1000 + 3600000 * 2,
-                                foci_active: [mockFocus],
-                                created_ts: 1000,
-                                membershipID: expect.stringMatching(".*"),
-                            },
-                        ],
-                    },
-                    "@alice:example.org",
-                );
-            } finally {
-                jest.useRealTimers();
-            }
-        });
    });

    describe("onMembershipsChanged", () => {
        it("does not emit if no membership changes", () => {
-            const mockRoom = makeMockRoom([membershipTemplate]);
+            const mockRoom = makeMockRoom(membershipTemplate);
            sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);

            const onMembershipsChanged = jest.fn();
            sess.on(MatrixRTCSessionEvent.MembershipsChanged, onMembershipsChanged);
-            sess.onMembershipUpdate();
+            sess.onRTCSessionMemberUpdate();

            expect(onMembershipsChanged).not.toHaveBeenCalled();
        });

        it("emits on membership changes", () => {
-            const mockRoom = makeMockRoom([membershipTemplate]);
+            const mockRoom = makeMockRoom(membershipTemplate);
            sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);

            const onMembershipsChanged = jest.fn();
            sess.on(MatrixRTCSessionEvent.MembershipsChanged, onMembershipsChanged);

            mockRoom.getLiveTimeline().getState = jest.fn().mockReturnValue(makeMockRoomState([], mockRoom.roomId));
-            sess.onMembershipUpdate();
+            sess.onRTCSessionMemberUpdate();

            expect(onMembershipsChanged).toHaveBeenCalled();
        });

-        it("emits an event at the time a membership event expires", () => {
-            jest.useFakeTimers();
-            try {
-                const membership = Object.assign({}, membershipTemplate);
-                const mockRoom = makeMockRoom([membership]);
+        // TODO: re-enable this test when expiry is implemented
+        // eslint-disable-next-line jest/no-commented-out-tests
+        // it("emits an event at the time a membership event expires", () => {
+        //     jest.useFakeTimers();
+        //     try {
+        //         const membership = Object.assign({}, membershipTemplate);
+        //         const mockRoom = makeMockRoom([membership]);

-                sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
-                const membershipObject = sess.memberships[0];
+        //         sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
+        //         const membershipObject = sess.memberships[0];

-                const onMembershipsChanged = jest.fn();
-                sess.on(MatrixRTCSessionEvent.MembershipsChanged, onMembershipsChanged);
+        //         const onMembershipsChanged = jest.fn();
+        //         sess.on(MatrixRTCSessionEvent.MembershipsChanged, onMembershipsChanged);

-                jest.advanceTimersByTime(61 * 1000 * 1000);
+        //         jest.advanceTimersByTime(61 * 1000 * 1000);

-                expect(onMembershipsChanged).toHaveBeenCalledWith([membershipObject], []);
-                expect(sess?.memberships.length).toEqual(0);
-            } finally {
-                jest.useRealTimers();
-            }
-        });
+        //         expect(onMembershipsChanged).toHaveBeenCalledWith([membershipObject], []);
+        //         expect(sess?.memberships.length).toEqual(0);
+        //     } finally {
+        //         jest.useRealTimers();
+        //     }
+        // });
    });

    describe("key management", () => {
@@ -805,9 +666,13 @@ describe("MatrixRTCSession", () => {
                }
            });

-            it("does not send key if join called when already joined", () => {
+            it("does not send key if join called when already joined", async () => {
+                const sentStateEvent = new Promise((resolve) => {
+                    sendStateEventMock = jest.fn(resolve);
+                });
+                client.sendStateEvent = sendStateEventMock;
                sess!.joinRoomSession([mockFocus], mockFocus, { manageMediaKeys: true });
-
+                await sentStateEvent;
                expect(client.sendStateEvent).toHaveBeenCalledTimes(1);
                expect(client.sendEvent).toHaveBeenCalledTimes(1);
                expect(sess!.statistics.counters.roomEventEncryptionKeysSent).toEqual(1);
@@ -892,7 +757,7 @@ describe("MatrixRTCSession", () => {
                    mockRoom.getLiveTimeline().getState = jest
                        .fn()
                        .mockReturnValue(makeMockRoomState([membershipTemplate], mockRoom.roomId));
-                    sess.onMembershipUpdate();
+                    sess.onRTCSessionMemberUpdate();

                    // member2 re-joins which should trigger an immediate re-send
                    const keysSentPromise2 = new Promise<EncryptionKeysEventContent>((resolve) => {
@@ -901,7 +766,7 @@ describe("MatrixRTCSession", () => {
                    mockRoom.getLiveTimeline().getState = jest
                        .fn()
                        .mockReturnValue(makeMockRoomState([membershipTemplate, member2], mockRoom.roomId));
-                    sess.onMembershipUpdate();
+                    sess.onRTCSessionMemberUpdate();
                    // but, that immediate resend is throttled so we need to wait a bit
                    jest.advanceTimersByTime(1000);
                    const { keys } = await keysSentPromise2;
@@ -954,7 +819,7 @@ describe("MatrixRTCSession", () => {
                    mockRoom.getLiveTimeline().getState = jest
                        .fn()
                        .mockReturnValue(makeMockRoomState([membershipTemplate, member2], mockRoom.roomId));
-                    sess.onMembershipUpdate();
+                    sess.onRTCSessionMemberUpdate();

                    await keysSentPromise2;

@@ -1008,7 +873,7 @@ describe("MatrixRTCSession", () => {
                    sendEventMock.mockClear();

                    // these should be a no-op:
-                    sess.onMembershipUpdate();
+                    sess.onRTCSessionMemberUpdate();
                    expect(sendEventMock).toHaveBeenCalledTimes(0);
                    expect(sess!.statistics.counters.roomEventEncryptionKeysSent).toEqual(1);
                } finally {
@@ -1016,89 +881,6 @@ describe("MatrixRTCSession", () => {
                }
            });

-            it("re-sends key if a member changes membership ID", async () => {
-                jest.useFakeTimers();
-                try {
-                    const keysSentPromise1 = new Promise((resolve) => {
-                        sendEventMock.mockImplementation(resolve);
-                    });
-
-                    const member1 = membershipTemplate;
-                    const member2 = {
-                        ...membershipTemplate,
-                        device_id: "BBBBBBB",
-                    };
-
-                    const mockRoom = makeMockRoom([member1, member2]);
-                    mockRoom.getLiveTimeline().getState = jest
-                        .fn()
-                        .mockReturnValue(makeMockRoomState([member1, member2], mockRoom.roomId));
-
-                    sess = MatrixRTCSession.roomSessionForRoom(client, mockRoom);
-                    sess.joinRoomSession([mockFocus], mockFocus, { manageMediaKeys: true });
-
-                    await keysSentPromise1;
-
-                    // make sure an encryption key was sent
-                    expect(sendEventMock).toHaveBeenCalledWith(
-                        expect.stringMatching(".*"),
-                        "io.element.call.encryption_keys",
-                        {
-                            call_id: "",
-                            device_id: "AAAAAAA",
-                            keys: [
-                                {
-                                    index: 0,
-                                    key: expect.stringMatching(".*"),
-                                },
-                            ],
-                            sent_ts: Date.now(),
-                        },
-                    );
-                    expect(sess!.statistics.counters.roomEventEncryptionKeysSent).toEqual(1);
-
-                    sendEventMock.mockClear();
-
-                    // this should be a no-op:
-                    sess.onMembershipUpdate();
-                    expect(sendEventMock).toHaveBeenCalledTimes(0);
-
-                    // advance time to avoid key throttling
-                    jest.advanceTimersByTime(10000);
-
-                    // update membership ID
-                    member2.membershipID = "newID";
-
-                    const keysSentPromise2 = new Promise((resolve) => {
-                        sendEventMock.mockImplementation(resolve);
-                    });
-
-                    // this should re-send the key
-                    sess.onMembershipUpdate();
-
-                    await keysSentPromise2;
-
-                    expect(sendEventMock).toHaveBeenCalledWith(
-                        expect.stringMatching(".*"),
-                        "io.element.call.encryption_keys",
-                        {
-                            call_id: "",
-                            device_id: "AAAAAAA",
-                            keys: [
-                                {
-                                    index: 0,
-                                    key: expect.stringMatching(".*"),
-                                },
-                            ],
-                            sent_ts: Date.now(),
-                        },
-                    );
-                    expect(sess!.statistics.counters.roomEventEncryptionKeysSent).toEqual(2);
-                } finally {
-                    jest.useRealTimers();
-                }
-            });
-
            it("re-sends key if a member changes created_ts", async () => {
                jest.useFakeTimers();
                jest.setSystemTime(1000);
@@ -1145,7 +927,7 @@ describe("MatrixRTCSession", () => {
                    sendEventMock.mockClear();

                    // this should be a no-op:
-                    sess.onMembershipUpdate();
+                    sess.onRTCSessionMemberUpdate();
                    expect(sendEventMock).toHaveBeenCalledTimes(0);

                    // advance time to avoid key throttling
@@ -1159,7 +941,7 @@ describe("MatrixRTCSession", () => {
                    });

                    // this should re-send the key
-                    sess.onMembershipUpdate();
+                    sess.onRTCSessionMemberUpdate();

                    await keysSentPromise2;

@@ -1222,7 +1004,7 @@ describe("MatrixRTCSession", () => {
                    mockRoom.getLiveTimeline().getState = jest
                        .fn()
                        .mockReturnValue(makeMockRoomState([membershipTemplate], mockRoom.roomId));
-                    sess.onMembershipUpdate();
+                    sess.onRTCSessionMemberUpdate();

                    jest.advanceTimersByTime(10000);

@@ -1240,7 +1022,7 @@ describe("MatrixRTCSession", () => {
            it("wraps key index around to 0 when it reaches the maximum", async () => {
                // this should give us keys with index [0...255, 0, 1]
                const membersToTest = 258;
-                const members: CallMembershipData[] = [];
+                const members: SessionMembershipData[] = [];
                for (let i = 0; i < membersToTest; i++) {
                    members.push(Object.assign({}, membershipTemplate, { device_id: `DEVICE${i}` }));
                }
@@ -1267,7 +1049,7 @@ describe("MatrixRTCSession", () => {
                                );
                        }

-                        sess!.onMembershipUpdate();
+                        sess!.onRTCSessionMemberUpdate();

                        // advance time to avoid key throttling
                        jest.advanceTimersByTime(10000);
@@ -1308,7 +1090,7 @@ describe("MatrixRTCSession", () => {
                    mockRoom.getLiveTimeline().getState = jest
                        .fn()
                        .mockReturnValue(makeMockRoomState([membershipTemplate, member2], mockRoom.roomId));
-                    sess.onMembershipUpdate();
+                    sess.onRTCSessionMemberUpdate();

                    await new Promise((resolve) => {
                        realSetTimeout(resolve);
@@ -14,29 +14,20 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

+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";
-import { CallMembershipData } from "../../../src/matrixrtc/CallMembership";
 import { MatrixRTCSessionManagerEvents } from "../../../src/matrixrtc/MatrixRTCSessionManager";
-import { makeMockRoom } from "./mocks";
-
-const membershipTemplate: CallMembershipData = {
-    call_id: "",
-    scope: "m.room",
-    application: "m.call",
-    device_id: "AAAAAAA",
-    expires: 60 * 60 * 1000,
-    membershipID: "bloop",
-    foci_active: [{ type: "test" }],
-};
+import { makeMockRoom, makeMockRoomState, membershipTemplate } from "./mocks";

 describe("MatrixRTCSessionManager", () => {
    let client: MatrixClient;
@@ -69,16 +60,15 @@ describe("MatrixRTCSessionManager", () => {
    it("Fires event when session ends", () => {
        const onEnded = jest.fn();
        client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
-
-        const memberships = [membershipTemplate];
-
-        const room1 = makeMockRoom(memberships);
+        const room1 = makeMockRoom(membershipTemplate);
        jest.spyOn(client, "getRooms").mockReturnValue([room1]);
        jest.spyOn(client, "getRoom").mockReturnValue(room1);

        client.emit(ClientEvent.Room, room1);

-        memberships.splice(0, 1);
+        (room1.getLiveTimeline as Mock).mockReturnValue({
+            getState: jest.fn().mockReturnValue(makeMockRoomState([{}], room1.roomId)),
+        });

        const roomState = room1.getLiveTimeline().getState(EventTimeline.FORWARDS)!;
        const membEvent = roomState.getStateEvents("")[0];
@@ -14,17 +14,37 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

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

-type MembershipData = CallMembershipData[] | SessionMembershipData;
+type MembershipData = SessionMembershipData[] | SessionMembershipData | {};
+
+export const membershipTemplate: SessionMembershipData = {
+    application: "m.call",
+    call_id: "",
+    device_id: "AAAAAAA",
+    scope: "m.room",
+    focus_active: { type: "livekit", livekit_service_url: "https://lk.url" },
+    foci_preferred: [
+        {
+            livekit_alias: "!alias:something.org",
+            livekit_service_url: "https://livekit-jwt.something.io",
+            type: "livekit",
+        },
+        {
+            livekit_alias: "!alias:something.org",
+            livekit_service_url: "https://livekit-jwt.something.dev",
+            type: "livekit",
+        },
+    ],
+};

 export function makeMockRoom(membershipData: MembershipData): Room {
-    const roomId = randomString(8);
+    const roomId = secureRandomString(8);
    // Caching roomState here so it does not get recreated when calling `getLiveTimeline.getState()`
    const roomState = makeMockRoomState(membershipData, roomId);
-    return {
+    const room = {
        roomId: roomId,
        hasMembershipState: jest.fn().mockReturnValue(true),
        getLiveTimeline: jest.fn().mockReturnValue({
@@ -32,41 +52,46 @@ export function makeMockRoom(membershipData: MembershipData): Room {
        }),
        getVersion: jest.fn().mockReturnValue("default"),
    } as unknown as Room;
+    return room;
 }

 export function makeMockRoomState(membershipData: MembershipData, roomId: string) {
-    const event = mockRTCEvent(membershipData, roomId);
+    const events = Array.isArray(membershipData)
+        ? membershipData.map((m) => mockRTCEvent(m, roomId))
+        : [mockRTCEvent(membershipData, roomId)];
+    const keysAndEvents = events.map((e) => {
+        const data = e.getContent() as SessionMembershipData;
+        return [`_${e.sender?.userId}_${data.device_id}`];
+    });
+
    return {
        on: jest.fn(),
        off: jest.fn(),
        getStateEvents: (_: string, stateKey: string) => {
-            if (stateKey !== undefined) return event;
-            return [event];
+            if (stateKey !== undefined) return keysAndEvents.find(([k]) => k === stateKey)?.[1];
+            return events;
        },
-        events: new Map([
-            [
-                event.getType(),
-                {
-                    size: () => true,
-                    has: (_stateKey: string) => true,
-                    get: (_stateKey: string) => event,
-                    values: () => [event],
-                },
-            ],
-        ]),
+        events:
+            events.length === 0
+                ? new Map()
+                : new Map([
+                      [
+                          EventType.GroupCallMemberPrefix,
+                          {
+                              size: () => true,
+                              has: (stateKey: string) => keysAndEvents.find(([k]) => k === stateKey),
+                              get: (stateKey: string) => keysAndEvents.find(([k]) => k === stateKey)?.[1],
+                              values: () => events,
+                          },
+                      ],
+                  ]),
    };
 }

 export function mockRTCEvent(membershipData: MembershipData, roomId: string): MatrixEvent {
    return {
        getType: jest.fn().mockReturnValue(EventType.GroupCallMemberPrefix),
-        getContent: jest.fn().mockReturnValue(
-            !Array.isArray(membershipData)
-                ? membershipData
-                : {
-                      memberships: membershipData,
-                  },
-        ),
+        getContent: jest.fn().mockReturnValue(membershipData),
        getSender: jest.fn().mockReturnValue("@mock:user.example"),
        getTs: jest.fn().mockReturnValue(Date.now()),
        getRoomId: jest.fn().mockReturnValue(roomId),
@@ -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;
--- a/Show More
+++ b/Show More