v23.2.0

* refactor: sliding sync: swap to lists-as-keys

Update the request/response API shape to match the latest
MSC3575 version, which converts `lists` from being an array
of list objects to being a map of list objects.

* Linting

* prettier

* add extra setListRanges test

* Default to right type

.babelrc

@@ -1,12 +1,15 @@
 {
     "sourceMaps": true,
     "presets": [
-        ["@babel/preset-env", {
-            "targets": {
-                "node": 10
-            },
-            "modules": "commonjs"
-        }],
+        [
+            "@babel/preset-env",
+            {
+                "targets": {
+                    "node": 10
+                },
+                "modules": "commonjs"
+            }
+        ],
         "@babel/preset-typescript"
     ],
     "plugins": [

.eslintrc.js

@@ -1,63 +1,115 @@
 module.exports = {
-    plugins: [
-        "matrix-org",
-    ],
-    extends: [
-        "plugin:matrix-org/babel",
-    ],
+    plugins: ["matrix-org", "import", "jsdoc"],
+    extends: ["plugin:matrix-org/babel", "plugin:import/typescript"],
     env: {
         browser: true,
         node: true,
     },
+    settings: {
+        "import/resolver": {
+            typescript: true,
+            node: true,
+        },
+    },
+    // NOTE: These rules are frozen and new rules should not be added here.
+    // New changes belong in https://github.com/matrix-org/eslint-plugin-matrix-org/
     rules: {
-        "no-var": ["warn"],
-        "prefer-rest-params": ["warn"],
-        "prefer-spread": ["warn"],
-        "one-var": ["warn"],
-        "padded-blocks": ["warn"],
-        "no-extend-native": ["warn"],
-        "camelcase": ["warn"],
-        "no-multi-spaces": ["error", { "ignoreEOLComments": true }],
-        "space-before-function-paren": ["error", {
-            "anonymous": "never",
-            "named": "never",
-            "asyncArrow": "always",
-        }],
+        "no-var": ["error"],
+        "prefer-rest-params": ["error"],
+        "prefer-spread": ["error"],
+        "one-var": ["error"],
+        "padded-blocks": ["error"],
+        "no-extend-native": ["error"],
+        "camelcase": ["error"],
+        "no-multi-spaces": ["error", { ignoreEOLComments: true }],
+        "space-before-function-paren": [
+            "error",
+            {
+                anonymous: "never",
+                named: "never",
+                asyncArrow: "always",
+            },
+        ],
         "arrow-parens": "off",
         "prefer-promise-reject-errors": "off",
-        "quotes": "off",
-        "indent": "off",
         "no-constant-condition": "off",
         "no-async-promise-executor": "off",
         // We use a `logger` intermediary module
         "no-console": "error",
 
         // restrict EventEmitters to force callers to use TypedEventEmitter
-        "no-restricted-imports": ["error", "events"],
+        "no-restricted-imports": [
+            "error",
+            {
+                name: "events",
+                message: "Please use TypedEventEmitter instead",
+            },
+        ],
+
+        "import/no-restricted-paths": [
+            "error",
+            {
+                zones: [
+                    {
+                        target: "./src/",
+                        from: "./src/index.ts",
+                        message:
+                            "The package index is dynamic between src and lib depending on " +
+                            "whether release or development, target the specific module or matrix.ts instead",
+                    },
+                ],
+            },
+        ],
     },
-    overrides: [{
-        files: [
-            "**/*.ts",
-        ],
-        extends: [
-            "plugin:matrix-org/typescript",
-        ],
-        rules: {
-            // TypeScript has its own version of this
-            "@babel/no-invalid-this": "off",
+    overrides: [
+        {
+            files: ["**/*.ts"],
+            plugins: ["eslint-plugin-tsdoc"],
+            extends: ["plugin:matrix-org/typescript"],
+            rules: {
+                // TypeScript has its own version of this
+                "@babel/no-invalid-this": "off",
 
-            // We're okay being explicit at the moment
-            "@typescript-eslint/no-empty-interface": "off",
-            // We disable this while we're transitioning
-            "@typescript-eslint/no-explicit-any": "off",
-            // We'd rather not do this but we do
-            "@typescript-eslint/ban-ts-comment": "off",
-            // We're okay with assertion errors when we ask for them
-            "@typescript-eslint/no-non-null-assertion": "off",
+                // We're okay being explicit at the moment
+                "@typescript-eslint/no-empty-interface": "off",
+                // We disable this while we're transitioning
+                "@typescript-eslint/no-explicit-any": "off",
+                // We'd rather not do this but we do
+                "@typescript-eslint/ban-ts-comment": "off",
+                // We're okay with assertion errors when we ask for them
+                "@typescript-eslint/no-non-null-assertion": "off",
 
-            "quotes": "off",
-            // We use a `logger` intermediary module
-            "no-console": "error",
+                // The non-TypeScript rule produces false positives
+                "func-call-spacing": "off",
+                "@typescript-eslint/func-call-spacing": ["error"],
+
+                "quotes": "off",
+                // We use a `logger` intermediary module
+                "no-console": "error",
+            },
         },
-    }],
+        {
+            // We don't need amazing docs in our spec files
+            files: ["src/**/*.ts"],
+            rules: {
+                "tsdoc/syntax": "error",
+                // We use some select jsdoc rules as the tsdoc linter has only one rule
+                "jsdoc/no-types": "error",
+                "jsdoc/empty-tags": "error",
+                "jsdoc/check-property-names": "error",
+                "jsdoc/check-values": "error",
+                // These need a bit more work before we can enable
+                // "jsdoc/check-param-names": "error",
+                // "jsdoc/check-indentation": "error",
+            },
+        },
+        {
+            files: ["spec/**/*.ts"],
+            rules: {
+                // We don't need super strict typing in test utilities
+                "@typescript-eslint/explicit-function-return-type": "off",
+                "@typescript-eslint/explicit-member-accessibility": "off",
+            },
+        },
+    ],
 };

.git-blame-ignore-revs

@@ -38,4 +38,5 @@ cee7f7a280a8c20bafc21c0a2911f60851f7a7ca
 7ed65407e6cdf292ce3cf659310c68d19dcd52b2
 # Switch to ESLint from JSHint (Google eslint rules as a base)
 e057956ede9ad1a931ff8050c411aca7907e0394
-
+# prettier
+349c2c2587c2885bb69eda4aa078b5383724cf5e

.github/CODEOWNERS

@@ -1 +1,6 @@
-* @matrix-org/element-web
+*                         @matrix-org/element-web
+/.github/workflows/**     @matrix-org/element-web-app-team
+/package.json             @matrix-org/element-web-app-team
+/yarn.lock                @matrix-org/element-web-app-team
+/src/webrtc               @matrix-org/element-call-reviewers
+/spec/*/webrtc            @matrix-org/element-call-reviewers

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,7 +1,13 @@
-<!-- Please read https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md before submitting your pull request -->
+<!-- Thanks for submitting a PR! Please ensure the following requirements are met in order for us to review your PR -->
 
-<!-- Include a Sign-Off as described in https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md#sign-off -->
+## Checklist
 
-<!-- To specify text for the changelog entry (otherwise the PR title will be used):
-Notes:
+-   [ ] Tests written for new code (and old code if feasible)
+-   [ ] Linter and other CI checks pass
+-   [ ] Sign-off given on the changes (see [CONTRIBUTING.md](https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md))
+
+<!--
+If you would like to specify text for the changelog entry other than your PR title, add the following:
+
+Notes: Add super cool feature
 -->

.github/renovate.json

@@ -0,0 +1,4 @@
+{
+    "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+    "extends": ["github>matrix-org/renovate-config-element-web"]
+}

.github/workflows/backport.yml

@@ -0,0 +1,30 @@
+name: Backport
+on:
+    pull_request_target:
+        types:
+            - closed
+            - labeled
+        branches:
+            - develop
+
+jobs:
+    backport:
+        name: Backport
+        runs-on: ubuntu-latest
+        # Only react to merged PRs for security reasons.
+        # See https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target.
+        if: >
+            github.event.pull_request.merged
+            && (
+              github.event.action == 'closed'
+              || (
+                github.event.action == 'labeled'
+                && contains(github.event.label.name, 'backport')
+              )
+            )
+        steps:
+            - uses: tibdex/backport@v2
+              with:
+                  labels_template: "<%= JSON.stringify([...labels, 'X-Release-Blocker']) %>"
+                  # We can't use GITHUB_TOKEN here or CI won't run on the new PR
+                  github_token: ${{ secrets.ELEMENT_BOT_TOKEN }}

.github/workflows/docs-pr-netlify.yaml

@@ -0,0 +1,34 @@
+name: Deploy documentation PR preview
+
+on:
+    workflow_run:
+        workflows: ["Static Analysis"]
+        types:
+            - completed
+
+jobs:
+    netlify:
+        if: github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.event == 'pull_request'
+        runs-on: ubuntu-latest
+        steps:
+            # There's a 'download artifact' action, but it hasn't been updated for the workflow_run action
+            # (https://github.com/actions/download-artifact/issues/60) so instead we get this mess:
+            - name: 📥 Download artifact
+              uses: dawidd6/action-download-artifact@bd10f381a96414ce2b13a11bfa89902ba7cea07f # v2.24.3
+              with:
+                  workflow: static_analysis.yml
+                  run_id: ${{ github.event.workflow_run.id }}
+                  name: docs
+                  path: docs
+
+            - name: 📤 Deploy to Netlify
+              uses: matrix-org/netlify-pr-preview@v1
+              with:
+                  path: docs
+                  owner: ${{ github.event.workflow_run.head_repository.owner.login }}
+                  branch: ${{ github.event.workflow_run.head_branch }}
+                  revision: ${{ github.event.workflow_run.head_sha }}
+                  token: ${{ secrets.NETLIFY_AUTH_TOKEN }}
+                  site_id: ${{ secrets.NETLIFY_SITE_ID }}
+                  desc: Documentation preview
+                  deployment_env: PR Documentation Preview

.github/workflows/jsdoc.yml

@@ -1,53 +0,0 @@
-name: Release Process
-on:
-  release:
-    types: [ published ]
-concurrency: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  jsdoc:
-    name: Publish Documentation
-    runs-on: ubuntu-latest
-    steps:
-      - name: 🧮 Checkout code
-        uses: actions/checkout@v3
-
-      - name: 🔧 Yarn cache
-        uses: actions/setup-node@v3
-        with:
-          cache: "yarn"
-
-      - name: 🔨 Install dependencies
-        run: "yarn install --pure-lockfile"
-
-      - name: 📖 Generate JSDoc
-        run: "yarn gendoc"
-
-      - name: 📋 Copy to temp
-        run: |
-          ls -lah
-          tag="${{ github.ref_name }}"
-          version="${tag#v}"
-          echo "VERSION=$version" >> $GITHUB_ENV
-          cp -a "./.jsdoc/matrix-js-sdk/$version" $RUNNER_TEMP
-
-      - name: 🧮 Checkout gh-pages
-        uses: actions/checkout@v3
-        with:
-          ref: gh-pages
-
-      - name: 🔪 Prepare
-        run: |
-          cp -a "$RUNNER_TEMP/$VERSION" .
-
-          # Add the new directory to the index if it isn't there already
-          if ! grep -q "Version $VERSION" index.html; then
-            perl -i -pe 'BEGIN {$rel=shift} $_ =~ /^<\/ul>/ && print
-              "<li><a href=\"${rel}/index.html\">Version ${rel}</a></li>\n"' "$VERSION" index.html
-          fi
-
-      - name: 🚀 Deploy
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          keep_files: true
-          publish_dir: .

.github/workflows/notify-downstream.yaml

@@ -1,27 +1,27 @@
 name: Notify Downstream Projects
 on:
-  push:
-    branches: [ develop ]
+    push:
+        branches: [develop]
 concurrency: ${{ github.workflow }}-${{ github.ref }}
 jobs:
-  notify-downstream:
-    # Only respect triggers from our develop branch, ignore that of forks
-    if: github.repository == 'matrix-org/matrix-js-sdk'
-    continue-on-error: true
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - repo: vector-im/element-web
-            event: element-web-notify
-          - repo: matrix-org/matrix-react-sdk
-            event: upstream-sdk-notify
+    notify-downstream:
+        # Only respect triggers from our develop branch, ignore that of forks
+        if: github.repository == 'matrix-org/matrix-js-sdk'
+        continue-on-error: true
+        strategy:
+            fail-fast: false
+            matrix:
+                include:
+                    - repo: vector-im/element-web
+                      event: element-web-notify
+                    - repo: matrix-org/matrix-react-sdk
+                      event: upstream-sdk-notify
 
-    runs-on: ubuntu-latest
-    steps:
-      - name: Notify matrix-react-sdk repo that a new SDK build is on develop so it can CI against it
-        uses: peter-evans/repository-dispatch@v1
-        with:
-          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-          repository: ${{ matrix.repo }}
-          event-type: ${{ matrix.event }}
+        runs-on: ubuntu-latest
+        steps:
+            - name: Notify matrix-react-sdk repo that a new SDK build is on develop so it can CI against it
+              uses: peter-evans/repository-dispatch@v2
+              with:
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  repository: ${{ matrix.repo }}
+                  event-type: ${{ matrix.event }}

.github/workflows/pull_request.yaml

@@ -1,92 +1,91 @@
 name: Pull Request
 on:
-  pull_request_target:
-    types: [ opened, edited, labeled, unlabeled, synchronize ]
-  workflow_call:
-    inputs:
-      labels:
-        type: string
-        default: "T-Defect,T-Deprecation,T-Enhancement,T-Task"
-        required: false
-        description: "No longer used, uses allchange logic now, will be removed at a later date"
-    secrets:
-      ELEMENT_BOT_TOKEN:
-        required: true
+    pull_request_target:
+        types: [opened, edited, labeled, unlabeled, synchronize]
+    workflow_call:
+        inputs:
+            labels:
+                type: string
+                default: "T-Defect,T-Deprecation,T-Enhancement,T-Task"
+                required: false
+                description: "No longer used, uses allchange logic now, will be removed at a later date"
+        secrets:
+            ELEMENT_BOT_TOKEN:
+                required: true
 concurrency: ${{ github.workflow }}-${{ github.event.pull_request.head.ref }}
 jobs:
-  changelog:
-    name: Preview Changelog
-    if: github.event.action != 'synchronize'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: matrix-org/allchange@main
-        with:
-          ghToken: ${{ secrets.GITHUB_TOKEN }}
-          requireLabel: true
+    changelog:
+        name: Preview Changelog
+        runs-on: ubuntu-latest
+        steps:
+            - uses: matrix-org/allchange@main
+              with:
+                  ghToken: ${{ secrets.GITHUB_TOKEN }}
+                  requireLabel: true
 
-  prevent-blocked:
-    name: Prevent Blocked
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: read
-    steps:
-      - name: Add notice
-        uses: actions/github-script@v5
-        if: contains(github.event.pull_request.labels.*.name, 'X-Blocked')
-        with:
-          script: |
-            core.setFailed("Preventing merge whilst PR is marked blocked!");
+    prevent-blocked:
+        name: Prevent Blocked
+        runs-on: ubuntu-latest
+        permissions:
+            pull-requests: read
+        steps:
+            - name: Add notice
+              uses: actions/github-script@v6
+              if: contains(github.event.pull_request.labels.*.name, 'X-Blocked')
+              with:
+                  script: |
+                      core.setFailed("Preventing merge whilst PR is marked blocked!");
 
-  community-prs:
-    name: Label Community PRs
-    runs-on: ubuntu-latest
-    if: github.event.action == 'opened'
-    steps:
-      - name: Check membership
-        uses: tspascoal/get-user-teams-membership@v1
-        id: teams
-        with:
-          username: ${{ github.event.pull_request.user.login }}
-          organization: matrix-org
-          team: Core Team
-          GITHUB_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}
+    community-prs:
+        name: Label Community PRs
+        runs-on: ubuntu-latest
+        if: github.event.action == 'opened'
+        steps:
+            - name: Check membership
+              uses: tspascoal/get-user-teams-membership@v2
+              id: teams
+              with:
+                  username: ${{ github.event.pull_request.user.login }}
+                  organization: matrix-org
+                  team: Core Team
+                  GITHUB_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}
 
-      - name: Add label
-        if: ${{ steps.teams.outputs.isTeamMember == 'false' }}
-        uses: actions/github-script@v5
-        with:
-          script: |
-            github.rest.issues.addLabels({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              labels: ['Z-Community-PR']
-            });
+            - name: Add label
+              if: ${{ steps.teams.outputs.isTeamMember == 'false' }}
+              uses: actions/github-script@v6
+              with:
+                  script: |
+                      github.rest.issues.addLabels({
+                        issue_number: context.issue.number,
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        labels: ['Z-Community-PR']
+                      });
 
-  close-if-fork-develop:
-    name: Forbid develop branch fork contributions
-    runs-on: ubuntu-latest
-    if: >
-      github.event.action == 'opened' &&
-      github.event.pull_request.head.ref == 'develop' &&
-      github.event.pull_request.head.repo.full_name != github.repository
-    steps:
-      - name: Close pull request
-        uses: actions/github-script@v5
-        with:
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: "Thanks for opening this pull request, unfortunately we do not accept contributions from the main" +
-                " branch of your fork, please re-open once you switch to an alternative branch for everyone's sanity." +
-                " See https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md",
-            });
+    close-if-fork-develop:
+        name: Forbid develop branch fork contributions
+        runs-on: ubuntu-latest
+        if: >
+            github.event.action == 'opened' &&
+            github.event.pull_request.head.ref == 'develop' &&
+            github.event.pull_request.head.repo.full_name != github.repository
+        steps:
+            - name: Close pull request
+              uses: actions/github-script@v6
+              with:
+                  script: |
+                      github.rest.issues.createComment({
+                        issue_number: context.issue.number,
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        body: "Thanks for opening this pull request, unfortunately we do not accept contributions from the main" +
+                          " branch of your fork, please re-open once you switch to an alternative branch for everyone's sanity." +
+                          " See https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md",
+                      });
 
-            github.rest.pulls.update({
-              pull_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              state: 'closed'
-            });
+                      github.rest.pulls.update({
+                        pull_number: context.issue.number,
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        state: 'closed'
+                      });

.github/workflows/release-npm.yml

@@ -0,0 +1,41 @@
+# Must only be called from `release#published` triggers
+name: Publish to npm
+on:
+    workflow_call:
+        secrets:
+            NPM_TOKEN:
+                required: true
+jobs:
+    npm:
+        name: Publish to npm
+        runs-on: ubuntu-latest
+        steps:
+            - name: 🧮 Checkout code
+              uses: actions/checkout@v3
+
+            - name: 🔧 Yarn cache
+              uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
+                  registry-url: "https://registry.npmjs.org"
+
+            - name: 🔨 Install dependencies
+              run: "yarn install --pure-lockfile"
+
+            - name: 🚀 Publish to npm
+              id: npm-publish
+              uses: JS-DevTools/npm-publish@v1
+              with:
+                  token: ${{ secrets.NPM_TOKEN }}
+                  access: public
+                  tag: next
+
+            - name: 🎖️ Add `latest` dist-tag to final releases
+              if: github.event.release.prerelease == false
+              run: |
+                  package=$(cat package.json | jq -er .name)
+                  npm dist-tag add "$package@$release" latest
+              env:
+                  # JS-DevTools/npm-publish overrides `NODE_AUTH_TOKEN` with `INPUT_TOKEN` in .npmrc
+                  INPUT_TOKEN: ${{ secrets.NPM_TOKEN }}
+                  release: ${{ steps.npm-publish.outputs.version }}

.github/workflows/release.yml

@@ -0,0 +1,59 @@
+name: Release Process
+on:
+    release:
+        types: [published]
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+    jsdoc:
+        name: Publish Documentation
+        runs-on: ubuntu-latest
+        steps:
+            - name: 🧮 Checkout code
+              uses: actions/checkout@v3
+
+            - name: 🔧 Yarn cache
+              uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
+
+            - name: 🔨 Install dependencies
+              run: "yarn install --pure-lockfile"
+
+            - name: 📖 Generate JSDoc
+              run: "yarn gendoc"
+
+            - name: 📋 Copy to temp
+              run: |
+                  cp -a "./_docs" "$RUNNER_TEMP/"
+
+            - name: 🧮 Checkout gh-pages
+              uses: actions/checkout@v3
+              with:
+                  ref: gh-pages
+
+            - name: 🔪 Prepare
+              env:
+                  GITHUB_REF_NAME: ${{ github.ref_name }}
+              run: |
+                  VERSION="${GITHUB_REF_NAME#v}"
+                  [ ! -e "$VERSION" ] || rm -r $VERSION
+                  cp -r $RUNNER_TEMP/_docs/ $VERSION
+
+                  # Add the new directory to the index if it isn't there already
+                  if ! grep -q ">Version $VERSION</a>" index.html; then
+                    perl -i -pe 'BEGIN {$rel=shift} $_ =~ /^<\/ul>/ && print
+                      "<li><a href=\"${rel}/index.html\">Version ${rel}</a></li>\n"' "$VERSION" index.html
+                  fi
+
+            - name: 🚀 Deploy
+              uses: peaceiris/actions-gh-pages@v3
+              with:
+                  github_token: ${{ secrets.GITHUB_TOKEN }}
+                  keep_files: true
+                  publish_dir: .
+
+    npm:
+        name: Publish
+        uses: matrix-org/matrix-js-sdk/.github/workflows/release-npm.yml@develop
+        secrets:
+            NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/sonarcloud.yml

@@ -1,24 +1,52 @@
 # Must only be called from a workflow_run in the context of the upstream repo
 name: SonarCloud
 on:
-  workflow_call:
-    secrets:
-      SONAR_TOKEN:
-        required: true
+    workflow_call:
+        secrets:
+            SONAR_TOKEN:
+                required: true
+        inputs:
+            extra_args:
+                type: string
+                required: false
+                description: "Extra args to pass to SonarCloud"
 jobs:
-  sonarqube:
-    runs-on: ubuntu-latest
-    if: github.event.workflow_run.conclusion == 'success'
-    steps:
-      - name: "🩻 SonarCloud Scan"
-        uses: matrix-org/sonarcloud-workflow-action@v2.2
-        with:
-          repository: ${{ github.event.workflow_run.head_repository.full_name }}
-          is_pr: ${{ github.event.workflow_run.event == 'pull_request' }}
-          version_cmd: 'cat package.json | jq -r .version'
-          branch: ${{ github.event.workflow_run.head_branch }}
-          revision: ${{ github.event.workflow_run.head_sha }}
-          token: ${{ secrets.SONAR_TOKEN }}
-          coverage_run_id: ${{ github.event.workflow_run.id }}
-          coverage_workflow_name: tests.yml
-          coverage_extract_path: coverage
+    sonarqube:
+        runs-on: ubuntu-latest
+        if: github.event.workflow_run.conclusion == 'success'
+        steps:
+            # We create the status here and then update it to success/failure in the `report` stage
+            # This provides an easy link to this workflow_run from the PR before Cypress is done.
+            - uses: Sibz/github-status-action@v1
+              with:
+                  authToken: ${{ secrets.GITHUB_TOKEN }}
+                  state: pending
+                  context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
+                  sha: ${{ github.event.workflow_run.head_sha }}
+                  target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}
+
+            - name: "🩻 SonarCloud Scan"
+              id: sonarcloud
+              uses: matrix-org/sonarcloud-workflow-action@v2.3
+              # workflow_run fails report against the develop commit always, we don't want that for PRs
+              continue-on-error: ${{ github.event.workflow_run.head_branch != 'develop' }}
+              with:
+                  repository: ${{ github.event.workflow_run.head_repository.full_name }}
+                  is_pr: ${{ github.event.workflow_run.event == 'pull_request' }}
+                  version_cmd: "cat package.json | jq -r .version"
+                  branch: ${{ github.event.workflow_run.head_branch }}
+                  revision: ${{ github.event.workflow_run.head_sha }}
+                  token: ${{ secrets.SONAR_TOKEN }}
+                  coverage_run_id: ${{ github.event.workflow_run.id }}
+                  coverage_workflow_name: tests.yml
+                  coverage_extract_path: coverage
+                  extra_args: ${{ inputs.extra_args }}
+
+            - uses: Sibz/github-status-action@v1
+              if: always()
+              with:
+                  authToken: ${{ secrets.GITHUB_TOKEN }}
+                  state: ${{ steps.sonarcloud.outcome == 'success' && 'success' || 'failure' }}
+                  context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
+                  sha: ${{ github.event.workflow_run.head_sha }}
+                  target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}

.github/workflows/sonarqube.yml

@@ -1,15 +1,43 @@
 name: SonarQube
 on:
-  workflow_run:
-    workflows: [ "Tests" ]
-    types:
-      - completed
+    workflow_run:
+        workflows: ["Tests"]
+        types:
+            - completed
 concurrency:
-  group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch }}
-  cancel-in-progress: true
+    group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch }}
+    cancel-in-progress: true
 jobs:
-  sonarqube:
-    name: 🩻 SonarQube
-    uses: matrix-org/matrix-js-sdk/.github/workflows/sonarcloud.yml@develop
-    secrets:
-      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+    # This is a workaround for https://github.com/SonarSource/SonarJS/issues/578
+    prepare:
+        name: Prepare
+        runs-on: ubuntu-latest
+        outputs:
+            reportPaths: ${{ steps.extra_args.outputs.reportPaths }}
+            testExecutionReportPaths: ${{ steps.extra_args.outputs.testExecutionReportPaths }}
+        steps:
+            # There's a 'download artifact' action, but it hasn't been updated for the workflow_run action
+            # (https://github.com/actions/download-artifact/issues/60) so instead we get this mess:
+            - name: 📥 Download artifact
+              uses: dawidd6/action-download-artifact@v2
+              with:
+                  workflow: tests.yaml
+                  run_id: ${{ github.event.workflow_run.id }}
+                  name: coverage
+                  path: coverage
+
+            - id: extra_args
+              run: |
+                  coverage=$(find coverage -type f -name '*lcov.info' | tr '\n' ',' | sed 's/,$//g')
+                  echo "reportPaths=$coverage" >> $GITHUB_OUTPUT
+                  reports=$(find coverage -type f -name 'jest-sonar-report*.xml' | tr '\n' ',' | sed 's/,$//g')
+                  echo "testExecutionReportPaths=$reports" >> $GITHUB_OUTPUT
+
+    sonarqube:
+        name: 🩻 SonarQube
+        needs: prepare
+        uses: matrix-org/matrix-js-sdk/.github/workflows/sonarcloud.yml@develop
+        secrets:
+            SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        with:
+            extra_args: -Dsonar.javascript.lcov.reportPaths=${{ needs.prepare.outputs.reportPaths }} -Dsonar.testExecutionReportPaths=${{ needs.prepare.outputs.testExecutionReportPaths }}

.github/workflows/static_analysis.yml

@@ -1,56 +1,74 @@
 name: Static Analysis
 on:
-  pull_request: { }
-  push:
-    branches: [ develop, master ]
+    pull_request: {}
+    push:
+        branches: [develop, master]
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
 jobs:
-  ts_lint:
-    name: "Typescript Syntax Check"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
+    ts_lint:
+        name: "Typescript Syntax Check"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
 
-      - uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
+            - uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
 
-      - name: Install Deps
-        run: "yarn install"
+            - name: Install Deps
+              run: "yarn install"
 
-      - name: Typecheck
-        run: "yarn run lint:types"
+            - name: Typecheck
+              run: "yarn run lint:types"
 
-  js_lint:
-    name: "ESLint"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
+            - name: Switch js-sdk to release mode
+              run: |
+                  scripts/switch_package_to_release.js
+                  yarn install
+                  yarn run build:compile
+                  yarn run build:types
 
-      - uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
+            - name: Typecheck (release mode)
+              run: "yarn run lint:types"
 
-      - name: Install Deps
-        run: "yarn install"
+    js_lint:
+        name: "ESLint"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
 
-      - name: Run Linter
-        run: "yarn run lint:js"
+            - uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
 
-  docs:
-    name: "JSDoc Checker"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
+            - name: Install Deps
+              run: "yarn install"
 
-      - uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
+            - name: Run Linter
+              run: "yarn run lint:js"
 
-      - name: Install Deps
-        run: "yarn install"
+    docs:
+        name: "JSDoc Checker"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
 
-      - name: Generate Docs
-        run: "yarn run gendoc"
+            - uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
+
+            - name: Install Deps
+              run: "yarn install"
+
+            - name: Generate Docs
+              run: "yarn run gendoc"
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v3
+              with:
+                  name: docs
+                  path: _docs
+                  # We'll only use this in a workflow_run, then we're done with it
+                  retention-days: 1

.github/workflows/tests.yml

@@ -1,37 +1,61 @@
 name: Tests
 on:
-  pull_request: { }
-  push:
-    branches: [ develop, master ]
+    pull_request: {}
+    push:
+        branches: [develop, master]
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
 jobs:
-  jest:
-    name: Jest
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
+    jest:
+        name: "Jest [${{ matrix.specs }}] (Node ${{ matrix.node }})"
+        runs-on: ubuntu-latest
+        timeout-minutes: 10
+        strategy:
+            matrix:
+                specs: [browserify, integ, unit]
+                node: [16, 18, latest]
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v3
 
-      - name: Yarn cache
-        uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
+            - name: Setup Node
+              uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
+                  node-version: ${{ matrix.node }}
 
-      - name: Install dependencies
-        run: "yarn install"
+            - name: Install dependencies
+              run: "yarn install"
 
-      - name: Build
-        run: "yarn build"
+            - name: Build
+              if: matrix.specs == 'browserify'
+              run: "yarn build"
 
-      - name: Run tests with coverage
-        run: "yarn coverage --ci --reporters github-actions"
+            - name: Get number of CPU cores
+              id: cpu-cores
+              uses: SimenB/github-actions-cpu-cores@v1
 
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: coverage
-          path: |
-            coverage
-            !coverage/lcov-report
+            - name: Run tests with coverage and metrics
+              if: github.ref == 'refs/heads/develop'
+              run: |
+                  yarn coverage --ci --reporters github-actions '--reporters=<rootDir>/spec/slowReporter.js' --max-workers ${{ steps.cpu-cores.outputs.count }} ./spec/${{ matrix.specs }}
+                  mv coverage/lcov.info coverage/${{ matrix.node }}-${{ matrix.specs }}.lcov.info
+              env:
+                  JEST_SONAR_UNIQUE_OUTPUT_NAME: true
+
+            - name: Run tests with coverage
+              if: github.ref != 'refs/heads/develop'
+              run: |
+                  yarn coverage --ci --reporters github-actions --max-workers ${{ steps.cpu-cores.outputs.count }} ./spec/${{ matrix.specs }}
+                  mv coverage/lcov.info coverage/${{ matrix.node }}-${{ matrix.specs }}.lcov.info
+              env:
+                  JEST_SONAR_UNIQUE_OUTPUT_NAME: true
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v3
+              with:
+                  name: coverage
+                  path: |
+                      coverage
+                      !coverage/lcov-report

.github/workflows/upgrade_dependencies.yml

@@ -1,38 +1,38 @@
 name: Upgrade Dependencies
 on:
-  workflow_dispatch: { }
-  workflow_call:
-    secrets:
-      ELEMENT_BOT_TOKEN:
-        required: true
+    workflow_dispatch: {}
+    workflow_call:
+        secrets:
+            ELEMENT_BOT_TOKEN:
+                required: true
 jobs:
-  upgrade:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
+    upgrade:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
 
-      - uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
+            - uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
 
-      - name: Upgrade
-        run: yarn upgrade && yarn install
+            - name: Upgrade
+              run: yarn upgrade && yarn install
 
-      - name: Create Pull Request
-        id: cpr
-        uses: peter-evans/create-pull-request@v4
-        with:
-          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-          branch: actions/upgrade-deps
-          delete-branch: true
-          title: Upgrade dependencies
-          labels: |
-            Dependencies
-            T-Task
-          
-      - name: Enable automerge
-        uses: peter-evans/enable-pull-request-automerge@v2
-        if: steps.cpr.outputs.pull-request-operation == 'created'
-        with:
-          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-          pull-request-number: ${{ steps.cpr.outputs.pull-request-number }}
+            - name: Create Pull Request
+              id: cpr
+              uses: peter-evans/create-pull-request@v4
+              with:
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  branch: actions/upgrade-deps
+                  delete-branch: true
+                  title: Upgrade dependencies
+                  labels: |
+                      Dependencies
+                      T-Task
+
+            - name: Enable automerge
+              uses: peter-evans/enable-pull-request-automerge@v2
+              if: steps.cpr.outputs.pull-request-operation == 'created'
+              with:
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  pull-request-number: ${{ steps.cpr.outputs.pull-request-number }}

.gitignore

@@ -1,5 +1,5 @@
-/.jsdocbuild
-/.jsdoc
+/_docs
+.DS_Store
 
 node_modules
 /.npmrc

.prettierignore

@@ -0,0 +1,26 @@
+/_docs
+.DS_Store
+
+/.npmrc
+/*.log
+package-lock.json
+.lock-wscript
+build/Release
+coverage
+lib-cov
+out
+/dist
+/lib
+/examples/browser/lib
+/examples/crypto-browser/lib
+/examples/voip/lib
+
+# version file and tarball created by `npm pack` / `yarn pack`
+/git-revision.txt
+/matrix-js-sdk-*.tgz
+
+.vscode
+.vscode/
+
+# This file is owned, parsed, and generated by allchange, which doesn't comply with prettier
+/CHANGELOG.md

.prettierrc.js

@@ -0,0 +1 @@
+module.exports = require("eslint-plugin-matrix-org/.prettierrc.js");

CHANGELOG.md

@@ -1,6 +1,356 @@
-Changes in [19.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.0.0-rc.1) (2022-06-28)
+Changes in [23.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v23.2.0) (2023-01-31)
+==================================================================================================
+
+## ✨ Features
+ * Implement decryption via the rust sdk ([\#3074](https://github.com/matrix-org/matrix-js-sdk/pull/3074)).
+ * Handle edits which are bundled with an event, per MSC3925 ([\#3045](https://github.com/matrix-org/matrix-js-sdk/pull/3045)).
+
+## 🐛 Bug Fixes
+ * Add null check for our own member event ([\#3082](https://github.com/matrix-org/matrix-js-sdk/pull/3082)).
+ * Handle group call getting initialised twice in quick succession ([\#3078](https://github.com/matrix-org/matrix-js-sdk/pull/3078)). Fixes vector-im/element-call#847.
+ * Correctly handle limited sync responses by resetting the thread timeline ([\#3056](https://github.com/matrix-org/matrix-js-sdk/pull/3056)). Fixes vector-im/element-web#23952. Contributed by @justjanne.
+ * Fix failure to start in firefox private browser ([\#3058](https://github.com/matrix-org/matrix-js-sdk/pull/3058)). Fixes vector-im/element-web#24216.
+ * Fix spurious "Decryption key withheld" messages ([\#3061](https://github.com/matrix-org/matrix-js-sdk/pull/3061)). Fixes vector-im/element-web#23803.
+ * Fix browser entrypoint ([\#3051](https://github.com/matrix-org/matrix-js-sdk/pull/3051)). Fixes #3013.
+
+Changes in [23.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v23.1.1) (2023-01-20)
+==================================================================================================
+
+## 🐛 Bug Fixes
+ * Fix backwards compability for environment not support Array.prototype.at ([\#3080](https://github.com/matrix-org/matrix-js-sdk/pull/3080)).
+
+Changes in [23.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v23.1.0) (2023-01-18)
+==================================================================================================
+
+## 🦖 Deprecations
+ * Remove extensible events v1 field population on legacy events ([\#3040](https://github.com/matrix-org/matrix-js-sdk/pull/3040)).
+
+## ✨ Features
+ * Improve hasUserReadEvent and getUserReadUpTo realibility with threads ([\#3031](https://github.com/matrix-org/matrix-js-sdk/pull/3031)). Fixes vector-im/element-web#24164.
+ * Remove video track when muting video ([\#3028](https://github.com/matrix-org/matrix-js-sdk/pull/3028)). Fixes vector-im/element-call#209.
+ * Make poll start event type available (PSG-962) ([\#3034](https://github.com/matrix-org/matrix-js-sdk/pull/3034)).
+ * Add alt event type matching in Relations model ([\#3018](https://github.com/matrix-org/matrix-js-sdk/pull/3018)).
+ * Remove usage of v1 Identity Server API ([\#3003](https://github.com/matrix-org/matrix-js-sdk/pull/3003)).
+ * Add `device_id` to `/account/whoami` types ([\#3005](https://github.com/matrix-org/matrix-js-sdk/pull/3005)).
+ * Implement MSC3912: Relation-based redactions ([\#2954](https://github.com/matrix-org/matrix-js-sdk/pull/2954)).
+ * Introduce a mechanism for using the rust-crypto-sdk ([\#2969](https://github.com/matrix-org/matrix-js-sdk/pull/2969)).
+ * Support MSC3391: Account data deletion ([\#2967](https://github.com/matrix-org/matrix-js-sdk/pull/2967)).
+
+## 🐛 Bug Fixes
+ * Fix threaded cache receipt when event holds multiple receipts ([\#3026](https://github.com/matrix-org/matrix-js-sdk/pull/3026)).
+ * Fix false key requests after verifying new device ([\#3029](https://github.com/matrix-org/matrix-js-sdk/pull/3029)). Fixes vector-im/element-web#24167 and vector-im/element-web#23333.
+ * Avoid triggering decryption errors when decrypting redacted events ([\#3004](https://github.com/matrix-org/matrix-js-sdk/pull/3004)). Fixes vector-im/element-web#24084.
+ * bugfix: upload OTKs in sliding sync mode ([\#3008](https://github.com/matrix-org/matrix-js-sdk/pull/3008)).
+ * Apply edits discovered from sync after thread is initialised ([\#3002](https://github.com/matrix-org/matrix-js-sdk/pull/3002)). Fixes vector-im/element-web#23921.
+ * Sliding sync: Fix issue where no unsubs are sent when switching rooms ([\#2991](https://github.com/matrix-org/matrix-js-sdk/pull/2991)).
+ * Threads are missing from the timeline ([\#2996](https://github.com/matrix-org/matrix-js-sdk/pull/2996)). Fixes vector-im/element-web#24036.
+ * Close all streams when a call ends ([\#2992](https://github.com/matrix-org/matrix-js-sdk/pull/2992)). Fixes vector-im/element-call#742.
+ * Resume to-device message queue after resumed sync ([\#2920](https://github.com/matrix-org/matrix-js-sdk/pull/2920)). Fixes matrix-org/element-web-rageshakes#17170.
+ * Fix browser entrypoint ([\#3051](https://github.com/matrix-org/matrix-js-sdk/pull/3051)). Fixes #3013.
+ * Fix failure to start in firefox private browser ([\#3058](https://github.com/matrix-org/matrix-js-sdk/pull/3058)). Fixes vector-im/element-web#24216.
+ * Correctly handle limited sync responses by resetting the thread timeline ([\#3056](https://github.com/matrix-org/matrix-js-sdk/pull/3056)). Fixes vector-im/element-web#23952.
+
+Changes in [23.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v23.0.0) (2022-12-21)
+==================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Process `m.room.encryption` events before emitting `RoomMember` events ([\#2914](https://github.com/matrix-org/matrix-js-sdk/pull/2914)). Fixes vector-im/element-web#23819.
+ * Don't expose `calls` on `GroupCall` ([\#2941](https://github.com/matrix-org/matrix-js-sdk/pull/2941)).
+
+## ✨ Features
+ * Support MSC3391: Account data deletion ([\#2967](https://github.com/matrix-org/matrix-js-sdk/pull/2967)).
+ * Add a message ID on each to-device message ([\#2938](https://github.com/matrix-org/matrix-js-sdk/pull/2938)).
+ * Enable multiple users' power levels to be set at once ([\#2892](https://github.com/matrix-org/matrix-js-sdk/pull/2892)). Contributed by @GoodGuyMarco.
+ * Include pending events in thread summary and count again ([\#2922](https://github.com/matrix-org/matrix-js-sdk/pull/2922)). Fixes vector-im/element-web#23642.
+ * Make GroupCall work better with widgets ([\#2935](https://github.com/matrix-org/matrix-js-sdk/pull/2935)).
+ * Add method to get outgoing room key requests for a given event ([\#2930](https://github.com/matrix-org/matrix-js-sdk/pull/2930)).
+
+## 🐛 Bug Fixes
+ * Fix messages loaded during initial fetch ending up out of order ([\#2971](https://github.com/matrix-org/matrix-js-sdk/pull/2971)). Fixes vector-im/element-web#23972.
+ * Fix #23919: Root message for new thread loaded from network ([\#2965](https://github.com/matrix-org/matrix-js-sdk/pull/2965)). Fixes vector-im/element-web#23919.
+ * Fix #23916: Prevent edits of the last message in a thread getting lost ([\#2951](https://github.com/matrix-org/matrix-js-sdk/pull/2951)). Fixes vector-im/element-web#23916 and vector-im/element-web#23942.
+ * Fix infinite loop when restoring cached read receipts ([\#2963](https://github.com/matrix-org/matrix-js-sdk/pull/2963)). Fixes vector-im/element-web#23951.
+ * Don't swallow errors coming from the shareSession call ([\#2962](https://github.com/matrix-org/matrix-js-sdk/pull/2962)). Fixes vector-im/element-web#23792.
+ * Make sure that MegolmEncryption.setupPromise always resolves  ([\#2960](https://github.com/matrix-org/matrix-js-sdk/pull/2960)).
+ * Do not calculate highlight notifs for threads unknown to the room ([\#2957](https://github.com/matrix-org/matrix-js-sdk/pull/2957)).
+ * Cache read receipts for unknown threads ([\#2953](https://github.com/matrix-org/matrix-js-sdk/pull/2953)).
+ * bugfix: sliding sync initial room timelines shouldn't notify ([\#2933](https://github.com/matrix-org/matrix-js-sdk/pull/2933)).
+ * Redo key sharing after own device verification ([\#2921](https://github.com/matrix-org/matrix-js-sdk/pull/2921)). Fixes vector-im/element-web#23333.
+ * Move updated threads to the end of the thread list ([\#2923](https://github.com/matrix-org/matrix-js-sdk/pull/2923)). Fixes vector-im/element-web#23876.
+ * Fix highlight notifications increasing when total notification is zero ([\#2937](https://github.com/matrix-org/matrix-js-sdk/pull/2937)). Fixes vector-im/element-web#23885.
+ * Fix synthesizeReceipt ([\#2916](https://github.com/matrix-org/matrix-js-sdk/pull/2916)). Fixes vector-im/element-web#23827 vector-im/element-web#23754 and vector-im/element-web#23847.
+
+Changes in [22.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v22.0.0) (2022-12-06)
+==================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Enable users to join group calls from multiple devices ([\#2902](https://github.com/matrix-org/matrix-js-sdk/pull/2902)).
+
+## 🦖 Deprecations
+ * Deprecate a function containing a typo ([\#2904](https://github.com/matrix-org/matrix-js-sdk/pull/2904)).
+
+## ✨ Features
+ * sliding sync: add receipts extension ([\#2912](https://github.com/matrix-org/matrix-js-sdk/pull/2912)).
+ * Define a spec support policy for the js-sdk ([\#2882](https://github.com/matrix-org/matrix-js-sdk/pull/2882)).
+ * Further improvements to e2ee logging ([\#2900](https://github.com/matrix-org/matrix-js-sdk/pull/2900)).
+ * sliding sync: add support for typing extension ([\#2893](https://github.com/matrix-org/matrix-js-sdk/pull/2893)).
+ * Improve logging on Olm session errors ([\#2885](https://github.com/matrix-org/matrix-js-sdk/pull/2885)).
+ * Improve logging of e2ee messages ([\#2884](https://github.com/matrix-org/matrix-js-sdk/pull/2884)).
+
+## 🐛 Bug Fixes
+ * Fix 3pid invite acceptance not working due to mxid being sent in body ([\#2907](https://github.com/matrix-org/matrix-js-sdk/pull/2907)). Fixes vector-im/element-web#23823.
+ * Don't hang up calls that haven't started yet ([\#2898](https://github.com/matrix-org/matrix-js-sdk/pull/2898)).
+ * Read receipt accumulation for threads ([\#2881](https://github.com/matrix-org/matrix-js-sdk/pull/2881)).
+ * Make GroupCall work better with widgets ([\#2935](https://github.com/matrix-org/matrix-js-sdk/pull/2935)).
+ * Fix highlight notifications increasing when total notification is zero ([\#2937](https://github.com/matrix-org/matrix-js-sdk/pull/2937)). Fixes vector-im/element-web#23885.
+ * Fix synthesizeReceipt ([\#2916](https://github.com/matrix-org/matrix-js-sdk/pull/2916)). Fixes vector-im/element-web#23827 vector-im/element-web#23754 and vector-im/element-web#23847.
+
+Changes in [21.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.2.0) (2022-11-22)
+==================================================================================================
+
+## ✨ Features
+ * Make calls go back to 'connecting' state when media lost ([\#2880](https://github.com/matrix-org/matrix-js-sdk/pull/2880)).
+ * Add ability to send unthreaded receipt ([\#2878](https://github.com/matrix-org/matrix-js-sdk/pull/2878)).
+ * Add way to abort search requests ([\#2877](https://github.com/matrix-org/matrix-js-sdk/pull/2877)).
+ * sliding sync: add custom room subscriptions support ([\#2834](https://github.com/matrix-org/matrix-js-sdk/pull/2834)).
+ * webrtc: add advanced audio settings ([\#2434](https://github.com/matrix-org/matrix-js-sdk/pull/2434)). Contributed by @MrAnno.
+ * Add support for group calls using MSC3401 ([\#2553](https://github.com/matrix-org/matrix-js-sdk/pull/2553)).
+ * Make the js-sdk conform to tsc --strict ([\#2835](https://github.com/matrix-org/matrix-js-sdk/pull/2835)). Fixes #2112 #2116 and #2124.
+ * Let leave requests outlive the window ([\#2815](https://github.com/matrix-org/matrix-js-sdk/pull/2815)). Fixes vector-im/element-call#639.
+ * Add event and message capabilities to RoomWidgetClient ([\#2797](https://github.com/matrix-org/matrix-js-sdk/pull/2797)).
+ * Misc fixes for group call widgets ([\#2657](https://github.com/matrix-org/matrix-js-sdk/pull/2657)).
+ * Support nested Matrix clients via the widget API ([\#2473](https://github.com/matrix-org/matrix-js-sdk/pull/2473)).
+ * Set max average bitrate on PTT calls ([\#2499](https://github.com/matrix-org/matrix-js-sdk/pull/2499)). Fixes vector-im/element-call#440.
+ * Add config option for e2e group call signalling ([\#2492](https://github.com/matrix-org/matrix-js-sdk/pull/2492)).
+ * Enable DTX on audio tracks in calls ([\#2482](https://github.com/matrix-org/matrix-js-sdk/pull/2482)).
+ * Don't ignore call member events with a distant future expiration date ([\#2466](https://github.com/matrix-org/matrix-js-sdk/pull/2466)).
+ * Expire call member state events after 1 hour ([\#2446](https://github.com/matrix-org/matrix-js-sdk/pull/2446)).
+ * Emit unknown device errors for group call participants without e2e ([\#2447](https://github.com/matrix-org/matrix-js-sdk/pull/2447)).
+ * Mute disconnected peers in PTT mode ([\#2421](https://github.com/matrix-org/matrix-js-sdk/pull/2421)).
+ * Add support for sending encrypted to-device events with OLM ([\#2322](https://github.com/matrix-org/matrix-js-sdk/pull/2322)). Contributed by @robertlong.
+ * Support for PTT group call mode ([\#2338](https://github.com/matrix-org/matrix-js-sdk/pull/2338)).
+
+## 🐛 Bug Fixes
+ * Fix registration add phone number not working ([\#2876](https://github.com/matrix-org/matrix-js-sdk/pull/2876)). Contributed by @bagvand.
+ * Use an underride rule for Element Call notifications ([\#2873](https://github.com/matrix-org/matrix-js-sdk/pull/2873)). Fixes vector-im/element-web#23691.
+ * Fixes unwanted highlight notifications with encrypted threads ([\#2862](https://github.com/matrix-org/matrix-js-sdk/pull/2862)).
+ * Extra insurance that we don't mix events in the wrong timelines - v2 ([\#2856](https://github.com/matrix-org/matrix-js-sdk/pull/2856)). Contributed by @MadLittleMods.
+ * Hide pending events in thread timelines ([\#2843](https://github.com/matrix-org/matrix-js-sdk/pull/2843)). Fixes vector-im/element-web#23684.
+ * Fix pagination token tracking for mixed room timelines ([\#2855](https://github.com/matrix-org/matrix-js-sdk/pull/2855)). Fixes vector-im/element-web#23695.
+ * Extra insurance that we don't mix events in the wrong timelines ([\#2848](https://github.com/matrix-org/matrix-js-sdk/pull/2848)). Contributed by @MadLittleMods.
+ * Do not freeze state in `initialiseState()` ([\#2846](https://github.com/matrix-org/matrix-js-sdk/pull/2846)).
+ * Don't remove our own member for a split second when entering a call ([\#2844](https://github.com/matrix-org/matrix-js-sdk/pull/2844)).
+ * Resolve races between `initLocalCallFeed` and `leave` ([\#2826](https://github.com/matrix-org/matrix-js-sdk/pull/2826)).
+ * Add throwOnFail to groupCall.setScreensharingEnabled ([\#2787](https://github.com/matrix-org/matrix-js-sdk/pull/2787)).
+ * Fix connectivity regressions ([\#2780](https://github.com/matrix-org/matrix-js-sdk/pull/2780)).
+ * Fix screenshare failing after several attempts ([\#2771](https://github.com/matrix-org/matrix-js-sdk/pull/2771)). Fixes vector-im/element-call#625.
+ * Don't block muting/unmuting on network requests ([\#2754](https://github.com/matrix-org/matrix-js-sdk/pull/2754)). Fixes vector-im/element-call#592.
+ * Fix ICE restarts ([\#2702](https://github.com/matrix-org/matrix-js-sdk/pull/2702)).
+ * Target widget actions at a specific room ([\#2670](https://github.com/matrix-org/matrix-js-sdk/pull/2670)).
+ * Add tests for ice candidate sending ([\#2674](https://github.com/matrix-org/matrix-js-sdk/pull/2674)).
+ * Prevent exception when muting ([\#2667](https://github.com/matrix-org/matrix-js-sdk/pull/2667)). Fixes vector-im/element-call#578.
+ * Fix race in creating calls ([\#2662](https://github.com/matrix-org/matrix-js-sdk/pull/2662)).
+ * Add client.waitUntilRoomReadyForGroupCalls() ([\#2641](https://github.com/matrix-org/matrix-js-sdk/pull/2641)).
+ * Wait for client to start syncing before making group calls ([\#2632](https://github.com/matrix-org/matrix-js-sdk/pull/2632)). Fixes #2589.
+ * Add GroupCallEventHandlerEvent.Room ([\#2631](https://github.com/matrix-org/matrix-js-sdk/pull/2631)).
+ * Add missing events from reemitter to GroupCall ([\#2527](https://github.com/matrix-org/matrix-js-sdk/pull/2527)). Contributed by @toger5.
+ * Prevent double mute status changed events ([\#2502](https://github.com/matrix-org/matrix-js-sdk/pull/2502)).
+ * Don't mute the remote side immediately in PTT calls ([\#2487](https://github.com/matrix-org/matrix-js-sdk/pull/2487)). Fixes vector-im/element-call#425.
+ * Fix some MatrixCall leaks and use a shared AudioContext ([\#2484](https://github.com/matrix-org/matrix-js-sdk/pull/2484)). Fixes vector-im/element-call#412.
+ * Don't block muting on determining whether the device exists ([\#2461](https://github.com/matrix-org/matrix-js-sdk/pull/2461)).
+ * Only clone streams on Safari ([\#2450](https://github.com/matrix-org/matrix-js-sdk/pull/2450)). Fixes vector-im/element-call#267.
+ * Set PTT mode on call correctly ([\#2445](https://github.com/matrix-org/matrix-js-sdk/pull/2445)). Fixes vector-im/element-call#382.
+ * Wait for mute event to send in PTT mode ([\#2401](https://github.com/matrix-org/matrix-js-sdk/pull/2401)).
+ * Handle other members having no e2e keys ([\#2383](https://github.com/matrix-org/matrix-js-sdk/pull/2383)). Fixes vector-im/element-call#338.
+ * Fix races when muting/unmuting ([\#2370](https://github.com/matrix-org/matrix-js-sdk/pull/2370)).
+
+Changes in [21.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.1.0) (2022-11-08)
+==================================================================================================
+
+## ✨ Features
+ * Loading threads with server-side assistance ([\#2735](https://github.com/matrix-org/matrix-js-sdk/pull/2735)). Contributed by @justjanne.
+ * Support sign in + E2EE set up using QR code implementing MSC3886, MSC3903 and MSC3906 ([\#2747](https://github.com/matrix-org/matrix-js-sdk/pull/2747)). Contributed by @hughns.
+
+## 🐛 Bug Fixes
+ * Replace `instanceof Array` with `Array.isArray` ([\#2812](https://github.com/matrix-org/matrix-js-sdk/pull/2812)). Fixes #2811.
+ * Emit UnreadNotification event on notifications reset ([\#2804](https://github.com/matrix-org/matrix-js-sdk/pull/2804)). Fixes vector-im/element-web#23590.
+ * Fix incorrect prevEv being sent in ClientEvent.AccountData events ([\#2794](https://github.com/matrix-org/matrix-js-sdk/pull/2794)).
+ * Fix build error caused by wrong ts-strict improvements ([\#2783](https://github.com/matrix-org/matrix-js-sdk/pull/2783)). Contributed by @justjanne.
+ * Encryption should not hinder verification ([\#2734](https://github.com/matrix-org/matrix-js-sdk/pull/2734)).
+
+Changes in [21.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.1) (2022-11-01)
+==================================================================================================
+
+## 🐛 Bug Fixes
+ * Fix default behavior of Room.getBlacklistUnverifiedDevices ([\#2830](https://github.com/matrix-org/matrix-js-sdk/pull/2830)). Contributed by @duxovni.
+ * Catch server versions API call exception when starting the client ([\#2828](https://github.com/matrix-org/matrix-js-sdk/pull/2828)). Fixes vector-im/element-web#23634.
+ * Fix authedRequest including `Authorization: Bearer undefined` for password resets ([\#2822](https://github.com/matrix-org/matrix-js-sdk/pull/2822)). Fixes vector-im/element-web#23655.
+
+Changes in [21.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.0) (2022-10-25)
+==================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Changes the `uploadContent` API, kills off `request` and `browser-request` in favour of `fetch`, removed callback support on a lot of the methods, adds a lot of tests. ([\#2719](https://github.com/matrix-org/matrix-js-sdk/pull/2719)). Fixes #2415 and #801.
+ * Remove deprecated `m.room.aliases` references ([\#2759](https://github.com/matrix-org/matrix-js-sdk/pull/2759)). Fixes vector-im/element-web#12680.
+
+## ✨ Features
+ * Remove node-specific crypto bits, use Node 16's WebCrypto ([\#2762](https://github.com/matrix-org/matrix-js-sdk/pull/2762)). Fixes #2760.
+ * Export types for MatrixEvent and Room emitted events, and make event handler map types stricter ([\#2750](https://github.com/matrix-org/matrix-js-sdk/pull/2750)). Contributed by @stas-demydiuk.
+ * Use even more stable calls to `/room_keys` ([\#2746](https://github.com/matrix-org/matrix-js-sdk/pull/2746)).
+ * Upgrade to Olm 3.2.13 which has been repackaged to support Node 18 ([\#2744](https://github.com/matrix-org/matrix-js-sdk/pull/2744)).
+ * Fix `power_level_content_override` type ([\#2741](https://github.com/matrix-org/matrix-js-sdk/pull/2741)).
+ * Add custom notification handling for MSC3401 call events  ([\#2720](https://github.com/matrix-org/matrix-js-sdk/pull/2720)).
+ * Add support for unread thread notifications ([\#2726](https://github.com/matrix-org/matrix-js-sdk/pull/2726)).
+ * Load Thread List with server-side assistance (MSC3856) ([\#2602](https://github.com/matrix-org/matrix-js-sdk/pull/2602)).
+ * Use stable calls to `/room_keys` ([\#2729](https://github.com/matrix-org/matrix-js-sdk/pull/2729)). Fixes vector-im/element-web#22839.
+
+## 🐛 Bug Fixes
+ * Fix POST data not being passed for registerWithIdentityServer ([\#2769](https://github.com/matrix-org/matrix-js-sdk/pull/2769)). Fixes matrix-org/element-web-rageshakes#16206.
+ * Fix IdentityPrefix.V2 containing spurious `/api` ([\#2761](https://github.com/matrix-org/matrix-js-sdk/pull/2761)). Fixes vector-im/element-web#23505.
+ * Always send back an httpStatus property if one is known ([\#2753](https://github.com/matrix-org/matrix-js-sdk/pull/2753)).
+ * Check for AbortError, not any generic connection error, to avoid tightlooping ([\#2752](https://github.com/matrix-org/matrix-js-sdk/pull/2752)).
+ * Correct the dir parameter of MSC3715 ([\#2745](https://github.com/matrix-org/matrix-js-sdk/pull/2745)). Contributed by @dhenneke.
+ * Fix sync init when thread unread notif is not supported ([\#2739](https://github.com/matrix-org/matrix-js-sdk/pull/2739)). Fixes vector-im/element-web#23435.
+ * Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
+
+Changes in [20.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.1.0) (2022-10-11)
 ============================================================================================================
 
+## ✨ Features
+ * Add local notification settings capability ([\#2700](https://github.com/matrix-org/matrix-js-sdk/pull/2700)).
+ * Implementation of MSC3882 login token request ([\#2687](https://github.com/matrix-org/matrix-js-sdk/pull/2687)). Contributed by @hughns.
+ * Typings for MSC2965 OIDC provider discovery ([\#2424](https://github.com/matrix-org/matrix-js-sdk/pull/2424)). Contributed by @hughns.
+ * Support to remotely toggle push notifications ([\#2686](https://github.com/matrix-org/matrix-js-sdk/pull/2686)).
+ * Read receipts for threads ([\#2635](https://github.com/matrix-org/matrix-js-sdk/pull/2635)).
+
+## 🐛 Bug Fixes
+ * Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
+ * Unexpected ignored self key request when it's not shared history ([\#2724](https://github.com/matrix-org/matrix-js-sdk/pull/2724)). Contributed by @mcalinghee.
+ * Fix IDB initial migration handling causing spurious lazy loading upgrade loops ([\#2718](https://github.com/matrix-org/matrix-js-sdk/pull/2718)). Fixes vector-im/element-web#23377.
+ * Fix backpagination at end logic being spec non-conforming ([\#2680](https://github.com/matrix-org/matrix-js-sdk/pull/2680)). Fixes vector-im/element-web#22784.
+
+Changes in [20.0.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.2) (2022-09-30)
+==================================================================================================
+
+## 🐛 Bug Fixes
+ * Fix issue in sync when crypto is not supported by client ([\#2715](https://github.com/matrix-org/matrix-js-sdk/pull/2715)). Contributed by @stas-demydiuk.
+
+Changes in [20.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.1) (2022-09-28)
+==================================================================================================
+
+## 🐛 Bug Fixes
+ * Fix missing return when receiving an invitation without shared history ([\#2710](https://github.com/matrix-org/matrix-js-sdk/pull/2710)).
+
+Changes in [20.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.0) (2022-09-28)
+==================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Bump IDB crypto store version ([\#2705](https://github.com/matrix-org/matrix-js-sdk/pull/2705)).
+
+Changes in [19.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.7.0) (2022-09-28)
+==================================================================================================
+
+## 🔒 Security
+* Fix for [CVE-2022-39249](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39249)
+* Fix for [CVE-2022-39250](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39250)
+* Fix for [CVE-2022-39251](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39251)
+* Fix for [CVE-2022-39236](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39236)
+
+Changes in [19.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.6.0) (2022-09-27)
+==================================================================================================
+
+## ✨ Features
+ * Add a property aggregating all names of a NamespacedValue ([\#2656](https://github.com/matrix-org/matrix-js-sdk/pull/2656)).
+ * Implementation of MSC3824 to add action= param on SSO login ([\#2398](https://github.com/matrix-org/matrix-js-sdk/pull/2398)). Contributed by @hughns.
+ * Add invited_count and joined_count to sliding sync room responses. ([\#2628](https://github.com/matrix-org/matrix-js-sdk/pull/2628)).
+ * Base support for MSC3847: Ignore invites with policy rooms ([\#2626](https://github.com/matrix-org/matrix-js-sdk/pull/2626)). Contributed by @Yoric.
+
+## 🐛 Bug Fixes
+ * Fix handling of remote echoes doubling up ([\#2639](https://github.com/matrix-org/matrix-js-sdk/pull/2639)). Fixes #2618.
+
+Changes in [19.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.5.0) (2022-09-13)
+==================================================================================================
+
+## 🐛 Bug Fixes
+ * Fix bug in deepCompare which would incorrectly return objects with disjoint keys as equal ([\#2586](https://github.com/matrix-org/matrix-js-sdk/pull/2586)). Contributed by @3nprob.
+ * Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
+ * Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
+ * Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
+
+Changes in [19.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.4.0) (2022-08-31)
+==================================================================================================
+
+## 🔒 Security
+* Fix for [CVE-2022-36059](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D36059)
+
+Find more details at https://matrix.org/blog/2022/08/31/security-releases-matrix-js-sdk-19-4-0-and-matrix-react-sdk-3-53-0
+
+## ✨ Features
+ * Re-emit room state events on rooms ([\#2607](https://github.com/matrix-org/matrix-js-sdk/pull/2607)).
+ * Add ability to override built in room name generator for an i18n'able one ([\#2609](https://github.com/matrix-org/matrix-js-sdk/pull/2609)).
+ * Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
+
+## 🐛 Bug Fixes
+ * Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
+ * Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
+ * Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
+ * fixed a sliding sync bug which could cause the `roomIndexToRoomId` map to be incorrect when a new room is added in the middle of the list or when an existing room is deleted from the middle of the list. ([\#2610](https://github.com/matrix-org/matrix-js-sdk/pull/2610)).
+ * Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078. Contributed by @kerryarchibald.
+ * Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
+ * fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
+
+Changes in [19.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.3.0) (2022-08-16)
+==================================================================================================
+
+## ✨ Features
+ * Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
+ * Emit an event when the client receives TURN servers ([\#2529](https://github.com/matrix-org/matrix-js-sdk/pull/2529)).
+ * Add support for stable prefixes for MSC2285 ([\#2524](https://github.com/matrix-org/matrix-js-sdk/pull/2524)).
+ * Remove stream-replacement ([\#2551](https://github.com/matrix-org/matrix-js-sdk/pull/2551)).
+ * Add support for sending user-defined encrypted to-device messages ([\#2528](https://github.com/matrix-org/matrix-js-sdk/pull/2528)).
+ * Retry to-device messages ([\#2549](https://github.com/matrix-org/matrix-js-sdk/pull/2549)). Fixes vector-im/element-web#12851.
+ * Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
+ * Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
+
+## 🐛 Bug Fixes
+ * Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078.
+ * Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
+ * Fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
+ * Don't load the sync accumulator if there's already a sync persist in flight ([\#2569](https://github.com/matrix-org/matrix-js-sdk/pull/2569)).
+
+Changes in [19.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.2.0) (2022-08-02)
+==================================================================================================
+
+## 🦖 Deprecations
+ * Remove unstable support for `m.room_key.withheld` ([\#2512](https://github.com/matrix-org/matrix-js-sdk/pull/2512)). Fixes #2233.
+
+## ✨ Features
+ * Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
+ * Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
+ * Add support for MSC3575: Sliding Sync ([\#2242](https://github.com/matrix-org/matrix-js-sdk/pull/2242)).
+
+## 🐛 Bug Fixes
+ * Correct the units in TURN servers expiry documentation ([\#2520](https://github.com/matrix-org/matrix-js-sdk/pull/2520)).
+ * Re-insert room IDs when decrypting bundled redaction events returned by `/sync` ([\#2531](https://github.com/matrix-org/matrix-js-sdk/pull/2531)). Contributed by @duxovni.
+
+Changes in [19.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.1.0) (2022-07-26)
+==================================================================================================
+
+## 🦖 Deprecations
+ * Remove MSC3244 support ([\#2504](https://github.com/matrix-org/matrix-js-sdk/pull/2504)).
+
+## ✨ Features
+ * `room` now exports `KNOWN_SAFE_ROOM_VERSION` ([\#2474](https://github.com/matrix-org/matrix-js-sdk/pull/2474)).
+
+## 🐛 Bug Fixes
+ * Don't crash with undefined room in `processBeaconEvents()` ([\#2500](https://github.com/matrix-org/matrix-js-sdk/pull/2500)). Fixes #2494.
+ * Properly re-insert room ID in bundled thread relation messages from sync ([\#2505](https://github.com/matrix-org/matrix-js-sdk/pull/2505)). Fixes vector-im/element-web#22094. Contributed by @duxovni.
+ * Actually store the identity server in the client when given as an option ([\#2503](https://github.com/matrix-org/matrix-js-sdk/pull/2503)). Fixes vector-im/element-web#22757.
+ * Fix call.collectCallStats() ([\#2480](https://github.com/matrix-org/matrix-js-sdk/pull/2480)).
+
+Changes in [19.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.0.0) (2022-07-05)
+==================================================================================================
+
 ## 🚨 BREAKING CHANGES
  * Remove unused sessionStore ([\#2455](https://github.com/matrix-org/matrix-js-sdk/pull/2455)).
 

CONTRIBUTING.md

@@ -1,284 +1,3 @@
-Contributing code to matrix-js-sdk
-==================================
+# Contributing code to matrix-js-sdk
 
-Everyone is welcome to contribute code to matrix-js-sdk, provided that they are
-willing to license their contributions under the same license as the project
-itself. We follow a simple 'inbound=outbound' model for contributions: the act
-of submitting an 'inbound' contribution means that the contributor agrees to
-license the code under the same terms as the project's overall 'outbound'
-license - in this case, Apache Software License v2 (see
-[LICENSE](LICENSE)).
-
-How to contribute
------------------
-
-The preferred and easiest way to contribute changes to the project is to fork
-it on github, and then create a pull request to ask us to pull your changes
-into our repo (https://help.github.com/articles/using-pull-requests/)
-
-We use GitHub's pull request workflow to review the contribution, and either
-ask you to make any refinements needed or merge it and make them ourselves.
-
-Things that should go into your PR description:
- * A changelog entry in the `Notes` section (see below)
- * References to any bugs fixed by the change (in GitHub's `Fixes` notation)
- * Describe the why and what is changing in the PR description so it's easy for
-   onlookers and reviewers to onboard and context switch. 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 both **before** and **after** screenshots to easily compare and discuss
-   what's changing.
- * Include a step-by-step testing strategy so that a reviewer can check out the
-   code locally and easily get to the point of testing your change.
- * Add comments to the diff for the reviewer that might help them to understand
-   why the change is necessary or how they might better understand and review it.
-
-We rely on information in pull request to populate the information that goes
-into the changelogs our users see, both for the JS SDK itself and also for some
-projects based on it. This is picked up from both labels on the pull request and
-the `Notes:` annotation in the description. By default, the PR title will be
-used for the changelog entry, but you can specify more options, as follows.
-
-To add a longer, more detailed description of the change for the changelog:
-
-
-*Fix llama herding bug*
-
-```
-Notes: Fix a bug (https://github.com/matrix-org/notaproject/issues/123) where the 'Herd' button would not herd more than 8 Llamas if the moon was in the waxing gibbous phase
-```
-
-For some PRs, it's not useful to have an entry in the user-facing changelog (this is
-the default for PRs labelled with `T-Task`):
-
-*Remove outdated comment from `Ungulates.ts`*
-```
-Notes: none
-```
-
-Sometimes, you're fixing a bug in a downstream project, in which case you want
-an entry in that project's changelog. You can do that too:
-
-*Fix another herding bug*
-```
-Notes: Fix a bug where the `herd()` function would only work on Tuesdays
-element-web notes: Fix a bug where the 'Herd' button only worked on Tuesdays
-```
-
-This example is for Element Web. You can specify:
- * matrix-react-sdk
- * element-web
- * element-desktop
-
-If your PR introduces a breaking change, use the `Notes` section in the same
-way, additionally adding the `X-Breaking-Change` label (see below). There's no need
-to specify in the notes that it's a breaking change - this will be added
-automatically based on the label - but remember to tell the developer how to
-migrate:
-
-*Remove legacy class*
-
-```
-Notes: Remove legacy `Camelopard` class. `Giraffe` should be used instead.
-```
-
-Other metadata can be added using labels.
- * `X-Breaking-Change`: A breaking change - adding this label will mean the change causes a *major* version bump.
- * `T-Enhancement`: A new feature - adding this label will mean the change causes a *minor* version bump.
- * `T-Defect`: A bug fix (in either code or docs).
- * `T-Task`: No user-facing changes, eg. code comments, CI fixes, refactors or tests. Won't have a changelog entry unless you specify one.
-
-If you don't have permission to add labels, your PR reviewer(s) can work with you
-to add them: ask in the PR description or comments.
-
-We use continuous integration, and all pull requests get automatically tested:
-if your change breaks the build, then the PR will show that there are failed
-checks, so please check back after a few minutes.
-
-Tests
------
-Your PR should include tests.
-
-For new user facing features in `matrix-react-sdk` or `element-web`, you
-must include:
-
-1. Comprehensive unit tests written in Jest. These are located in `/test`.
-2. "happy path" end-to-end tests.
-   These are located in `/test/end-to-end-tests` in `matrix-react-sdk`, and
-   are run using `element-web`. Ideally, you would also include tests for edge
-   and error cases.
-
-Unit tests are expected even when the feature is in labs. 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. End-to-end tests should be added prior to the feature
-leaving labs, but don't have to be present from the start (although it might
-be beneficial to have some running early, so you can test things faster).
-
-For bugs in those repos, your change must include at least one unit test or
-end-to-end test; which is best depends on what sort of test most concisely
-exercises the area.
-
-Changes to `matrix-js-sdk` must be accompanied by unit tests written in Jest.
-These are located in `/spec/`.
-
-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.
-
-Some sections of code are not sensible to add coverage for, such as those
-which explicitly inhibit noisy logging for tests. Which can be hidden using
-an istanbul magic comment as [documented here][1]. See example:
-```javascript
-/* istanbul ignore if */
-if (process.env.NODE_ENV !== "test") {
-    logger.error("Log line that is noisy enough in tests to want to skip");
-}
-```
-
-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
-----------
-The js-sdk aims to target TypeScript/ES6. All new files should be written in
-TypeScript and existing files should use ES6 principles where possible.
-
-Members should not be exported as a default export in general - it causes problems
-with the architecture of the SDK (index file becomes less clear) and could
-introduce naming problems (as default exports get aliased upon import). In
-general, avoid using `export default`.
-
-The remaining code-style for matrix-js-sdk is not formally documented, but
-contributors are encouraged to read the
-[code style document for matrix-react-sdk](https://github.com/matrix-org/matrix-react-sdk/blob/master/code_style.md)
-and follow the principles set out there.
-
-Please ensure your changes match the cosmetic style of the existing project,
-and ***never*** mix cosmetic and functional changes in the same commit, as it
-makes it horribly hard to review otherwise.
-
-Attribution
------------
-Everyone who contributes anything to Matrix is welcome to be listed in the
-AUTHORS.rst file for the project in question. Please feel free to include a
-change to AUTHORS.rst in your pull request to list yourself and a short
-description of the area(s) you've worked on. Also, we sometimes have swag to
-give away to contributors - if you feel that Matrix-branded apparel is missing
-from your life, please mail us your shipping address to matrix at matrix.org
-and we'll try to fix it :)
-
-Sign off
---------
-In order to have a concrete record that your contribution is intentional
-and you agree to license it under the same terms as the project's license, we've
-adopted the same lightweight approach that the Linux Kernel
-(https://www.kernel.org/doc/Documentation/SubmittingPatches), Docker
-(https://github.com/docker/docker/blob/master/CONTRIBUTING.md), and many other
-projects use: the DCO (Developer Certificate of Origin:
-http://developercertificate.org/). This is a simple declaration that you wrote
-the contribution or otherwise have the right to contribute it to Matrix:
-
-```
-Developer Certificate of Origin
-Version 1.1
-
-Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
-660 York Street, Suite 102,
-San Francisco, CA 94110 USA
-
-Everyone is permitted to copy and distribute verbatim copies of this
-license document, but changing it is not allowed.
-
-Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
-(a) The contribution was created in whole or in part by me and I
-    have the right to submit it under the open source license
-    indicated in the file; or
-
-(b) The contribution is based upon previous work that, to the best
-    of my knowledge, is covered under an appropriate open source
-    license and I have the right under that license to submit that
-    work with modifications, whether created in whole or in part
-    by me, under the same open source license (unless I am
-    permitted to submit under a different license), as indicated
-    in the file; or
-
-(c) The contribution was provided directly to me by some other
-    person who certified (a), (b) or (c) and I have not modified
-    it.
-
-(d) I understand and agree that this project and the contribution
-    are public and that a record of the contribution (including all
-    personal information I submit with it, including my sign-off) is
-    maintained indefinitely and may be redistributed consistent with
-    this project or the open source license(s) involved.
-```
-
-If you agree to this for your contribution, then all that's needed is to
-include the line in your commit or pull request comment:
-
-```
-Signed-off-by: Your Name <your@email.example.org>
-```
-
-We accept contributions under a legally identifiable name, such as your name on
-government documentation or common-law names (names claimed by legitimate usage
-or repute). Unfortunately, we cannot accept anonymous contributions at this
-time.
-
-Git allows you to add this signoff automatically when using the `-s` flag to
-`git commit`, which uses the name and email set in your `user.name` and
-`user.email` git configs.
-
-If you forgot to sign off your commits before making your pull request and are
-on Git 2.17+ you can mass signoff using rebase:
-
-```
-git rebase --signoff origin/develop
-```
-
-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.
-
-
-[1]: https://github.com/gotwarlost/istanbul/blob/master/ignoring-code-for-coverage.md
+matrix-js-sdk follows the same pattern as https://github.com/vector-im/element-web/blob/develop/CONTRIBUTING.md

README.md

@@ -6,21 +6,25 @@
 [![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
 [![Bugs](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=bugs)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
 
-Matrix Javascript SDK
-=====================
+# Matrix JavaScript SDK
 
-This is the [Matrix](https://matrix.org) Client-Server r0 SDK for
-JavaScript. This SDK can be run in a browser or in Node.js.
+This is the [Matrix](https://matrix.org) Client-Server SDK for JavaScript and TypeScript. This SDK can be run in a
+browser or in Node.js.
 
-Quickstart
-==========
+The Matrix specification is constantly evolving - while this SDK aims for maximum backwards compatibility, it only
+guarantees that a feature will be supported for at least 4 spec releases. For example, if a feature the js-sdk supports
+is removed in v1.4 then the feature is _eligible_ for removal from the SDK when v1.8 is released. This SDK has no
+guarantee on implementing all features of any particular spec release, currently. This can mean that the SDK will call
+endpoints from before Matrix 1.1, for example.
+
+# Quickstart
+
+## In a browser
 
-In a browser
-------------
 Download the browser version from
 https://github.com/matrix-org/matrix-js-sdk/releases/latest and add that as a
-``<script>`` to your page. There will be a global variable ``matrixcs``
-attached to ``window`` through which you can access the SDK. See below for how to
+`<script>` to your page. There will be a global variable `matrixcs`
+attached to `window` through which you can access the SDK. See below for how to
 include libolm to enable end-to-end-encryption.
 
 The browser bundle supports recent versions of browsers. Typically this is ES2015
@@ -29,26 +33,23 @@ or `> 0.5%, last 2 versions, Firefox ESR, not dead` if using
 
 Please check [the working browser example](examples/browser) for more information.
 
-In Node.js
-----------
+## In Node.js
 
 Ensure you have the latest LTS version of Node.js installed.
-
-This SDK targets Node 12 for compatibility, which translates to ES6. If you're using
-a bundler like webpack you'll likely have to transpile dependencies, including this
-SDK, to match your target browsers.
+This library relies on `fetch` which is available in Node from v18.0.0 - it should work fine also with polyfills.
+If you wish to use a ponyfill or adapter of some sort then pass it as `fetchFn` to the MatrixClient constructor options.
 
 Using `yarn` instead of `npm` is recommended. Please see the Yarn [install guide](https://classic.yarnpkg.com/en/docs/install)
 if you do not have it already.
 
-``yarn add matrix-js-sdk``
+`yarn add matrix-js-sdk`
 
 ```javascript
-  import * as sdk from "matrix-js-sdk";
-  const client = sdk.createClient("https://matrix.org");
-  client.publicRooms(function(err, data) {
+import * as sdk from "matrix-js-sdk";
+const client = sdk.createClient({ baseUrl: "https://matrix.org" });
+client.publicRooms(function (err, data) {
     console.log("Public Rooms: %s", JSON.stringify(data));
-  });
+});
 ```
 
 See below for how to include libolm to enable end-to-end-encryption. Please check
@@ -57,14 +58,14 @@ See below for how to include libolm to enable end-to-end-encryption. Please chec
 To start the client:
 
 ```javascript
-await client.startClient({initialSyncLimit: 10});
+await client.startClient({ initialSyncLimit: 10 });
 ```
 
 You can perform a call to `/sync` to get the current state of the client:
 
 ```javascript
-client.once('sync', function(state, prevState, res) {
-    if(state === 'PREPARED') {
+client.once("sync", function (state, prevState, res) {
+    if (state === "PREPARED") {
         console.log("prepared");
     } else {
         console.log(state);
@@ -77,8 +78,8 @@ To send a message:
 
 ```javascript
 const content = {
-    "body": "message text",
-    "msgtype": "m.text"
+    body: "message text",
+    msgtype: "m.text",
 };
 client.sendEvent("roomId", "m.room.message", content, "", (err, res) => {
     console.log(err);
@@ -88,11 +89,11 @@ client.sendEvent("roomId", "m.room.message", content, "", (err, res) => {
 To listen for message events:
 
 ```javascript
-client.on("Room.timeline", function(event, room, toStartOfTimeline) {
-  if (event.getType() !== "m.room.message") {
-    return; // only use messages
-  }
-  console.log(event.event.content.body);
+client.on("Room.timeline", function (event, room, toStartOfTimeline) {
+    if (event.getType() !== "m.room.message") {
+        return; // only use messages
+    }
+    console.log(event.event.content.body);
 });
 ```
 
@@ -100,73 +101,70 @@ By default, the `matrix-js-sdk` client uses the `MemoryStore` to store events as
 
 ```javascript
 Object.keys(client.store.rooms).forEach((roomId) => {
-  client.getRoom(roomId).timeline.forEach(t => {
-      console.log(t.event);
-  });
+    client.getRoom(roomId).timeline.forEach((t) => {
+        console.log(t.event);
+    });
 });
 ```
 
-What does this SDK do?
-----------------------
+## What does this SDK do?
 
 This SDK provides a full object model around the Matrix Client-Server API and emits
 events for incoming data and state changes. Aside from wrapping the HTTP API, it:
- - Handles syncing (via `/initialSync` and `/events`)
- - Handles the generation of "friendly" room and member names.
- - Handles historical `RoomMember` information (e.g. display names).
- - Manages room member state across multiple events (e.g. it handles typing, power
-   levels and membership changes).
- - Exposes high-level objects like `Rooms`, `RoomState`, `RoomMembers` and `Users`
-   which can be listened to for things like name changes, new messages, membership
-   changes, presence changes, and more.
- - Handle "local echo" of messages sent using the SDK. This means that messages
-   that have just been sent will appear in the timeline as 'sending', until it
-   completes. This is beneficial because it prevents there being a gap between
-   hitting the send button and having the "remote echo" arrive.
- - Mark messages which failed to send as not sent.
- - Automatically retry requests to send messages due to network errors.
- - Automatically retry requests to send messages due to rate limiting errors.
- - Handle queueing of messages.
- - Handles pagination.
- - Handle assigning push actions for events.
- - Handles room initial sync on accepting invites.
- - Handles WebRTC calling.
+
+-   Handles syncing (via `/initialSync` and `/events`)
+-   Handles the generation of "friendly" room and member names.
+-   Handles historical `RoomMember` information (e.g. display names).
+-   Manages room member state across multiple events (e.g. it handles typing, power
+    levels and membership changes).
+-   Exposes high-level objects like `Rooms`, `RoomState`, `RoomMembers` and `Users`
+    which can be listened to for things like name changes, new messages, membership
+    changes, presence changes, and more.
+-   Handle "local echo" of messages sent using the SDK. This means that messages
+    that have just been sent will appear in the timeline as 'sending', until it
+    completes. This is beneficial because it prevents there being a gap between
+    hitting the send button and having the "remote echo" arrive.
+-   Mark messages which failed to send as not sent.
+-   Automatically retry requests to send messages due to network errors.
+-   Automatically retry requests to send messages due to rate limiting errors.
+-   Handle queueing of messages.
+-   Handles pagination.
+-   Handle assigning push actions for events.
+-   Handles room initial sync on accepting invites.
+-   Handles WebRTC calling.
 
 Later versions of the SDK will:
- - Expose a `RoomSummary` which would be suitable for a recents page.
- - Provide different pluggable storage layers (e.g. local storage, database-backed)
 
-Usage
-=====
+-   Expose a `RoomSummary` which would be suitable for a recents page.
+-   Provide different pluggable storage layers (e.g. local storage, database-backed)
 
+# Usage
 
-Conventions
------------
+## Conventions
 
 ### Emitted events
 
-The SDK will emit events using an ``EventEmitter``. It also
-emits object models (e.g. ``Rooms``, ``RoomMembers``) when they
+The SDK will emit events using an `EventEmitter`. It also
+emits object models (e.g. `Rooms`, `RoomMembers`) when they
 are updated.
 
 ```javascript
-  // Listen for low-level MatrixEvents
-  client.on("event", function(event) {
+// Listen for low-level MatrixEvents
+client.on("event", function (event) {
     console.log(event.getType());
-  });
+});
 
-  // Listen for typing changes
-  client.on("RoomMember.typing", function(event, member) {
+// Listen for typing changes
+client.on("RoomMember.typing", function (event, member) {
     if (member.typing) {
-      console.log(member.name + " is typing...");
+        console.log(member.name + " is typing...");
+    } else {
+        console.log(member.name + " stopped typing.");
     }
-    else {
-      console.log(member.name + " stopped typing.");
-    }
-  });
+});
 
-  // start the client to setup the connection to the server
-  client.startClient();
+// start the client to setup the connection to the server
+client.startClient();
 ```
 
 ### Promises and Callbacks
@@ -183,11 +181,11 @@ The typical usage is something like:
   });
 ```
 
-Alternatively, if you have a Node.js-style ``callback(err, result)`` function,
+Alternatively, if you have a Node.js-style `callback(err, result)` function,
 you can pass the result of the promise into it with something like:
 
 ```javascript
-  matrixClient.someMethod(arg1, arg2).nodeify(callback);
+matrixClient.someMethod(arg1, arg2).nodeify(callback);
 ```
 
 The main thing to note is that it is problematic to discard the result of a
@@ -195,61 +193,65 @@ promise-returning function, as that will cause exceptions to go unobserved.
 
 Methods which return a promise show this in their documentation.
 
-Many methods in the SDK support *both* Node.js-style callbacks *and* Promises,
-via an optional ``callback`` argument. The callback support is now deprecated:
-new methods do not include a ``callback`` argument, and in the future it may be
+Many methods in the SDK support _both_ Node.js-style callbacks _and_ Promises,
+via an optional `callback` argument. The callback support is now deprecated:
+new methods do not include a `callback` argument, and in the future it may be
 removed from existing methods.
 
-Examples
---------
+## Examples
+
 This section provides some useful code snippets which demonstrate the
 core functionality of the SDK. These examples assume the SDK is setup like this:
 
 ```javascript
-   import * as sdk from "matrix-js-sdk";
-   const myUserId = "@example:localhost";
-   const myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
-   const matrixClient = sdk.createClient({
-       baseUrl: "http://localhost:8008",
-       accessToken: myAccessToken,
-       userId: myUserId
-   });
+import * as sdk from "matrix-js-sdk";
+const myUserId = "@example:localhost";
+const myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
+const matrixClient = sdk.createClient({
+    baseUrl: "http://localhost:8008",
+    accessToken: myAccessToken,
+    userId: myUserId,
+});
 ```
 
 ### Automatically join rooms when invited
 
 ```javascript
-   matrixClient.on("RoomMember.membership", function(event, member) {
-       if (member.membership === "invite" && member.userId === myUserId) {
-           matrixClient.joinRoom(member.roomId).then(function() {
-               console.log("Auto-joined %s", member.roomId);
-           });
-       }
-   });
+matrixClient.on("RoomMember.membership", function (event, member) {
+    if (member.membership === "invite" && member.userId === myUserId) {
+        matrixClient.joinRoom(member.roomId).then(function () {
+            console.log("Auto-joined %s", member.roomId);
+        });
+    }
+});
 
-   matrixClient.startClient();
+matrixClient.startClient();
 ```
 
 ### Print out messages for all rooms
 
 ```javascript
-   matrixClient.on("Room.timeline", function(event, room, toStartOfTimeline) {
-       if (toStartOfTimeline) {
-           return; // don't print paginated results
-       }
-       if (event.getType() !== "m.room.message") {
-           return; // only print messages
-       }
-       console.log(
-           // the room name will update with m.room.name events automatically
-           "(%s) %s :: %s", room.name, event.getSender(), event.getContent().body
-       );
-   });
+matrixClient.on("Room.timeline", function (event, room, toStartOfTimeline) {
+    if (toStartOfTimeline) {
+        return; // don't print paginated results
+    }
+    if (event.getType() !== "m.room.message") {
+        return; // only print messages
+    }
+    console.log(
+        // the room name will update with m.room.name events automatically
+        "(%s) %s :: %s",
+        room.name,
+        event.getSender(),
+        event.getContent().body,
+    );
+});
 
-   matrixClient.startClient();
+matrixClient.startClient();
 ```
 
 Output:
+
 ```
   (My Room) @megan:localhost :: Hello world
   (My Room) @megan:localhost :: how are you?
@@ -261,27 +263,24 @@ Output:
 ### Print out membership lists whenever they are changed
 
 ```javascript
-   matrixClient.on("RoomState.members", function(event, state, member) {
-       const room = matrixClient.getRoom(state.roomId);
-       if (!room) {
-           return;
-       }
-       const memberList = state.getMembers();
-       console.log(room.name);
-       console.log(Array(room.name.length + 1).join("="));  // underline
-       for (var i = 0; i < memberList.length; i++) {
-           console.log(
-               "(%s) %s",
-               memberList[i].membership,
-               memberList[i].name
-           );
-       }
-   });
+matrixClient.on("RoomState.members", function (event, state, member) {
+    const room = matrixClient.getRoom(state.roomId);
+    if (!room) {
+        return;
+    }
+    const memberList = state.getMembers();
+    console.log(room.name);
+    console.log(Array(room.name.length + 1).join("=")); // underline
+    for (var i = 0; i < memberList.length; i++) {
+        console.log("(%s) %s", memberList[i].membership, memberList[i].name);
+    }
+});
 
-   matrixClient.startClient();
+matrixClient.startClient();
 ```
 
 Output:
+
 ```
   My Room
   =======
@@ -291,36 +290,34 @@ Output:
   (invite) @charlie:localhost
 ```
 
-API Reference
-=============
+# API Reference
 
 A hosted reference can be found at
 http://matrix-org.github.io/matrix-js-sdk/index.html
 
-This SDK uses JSDoc3 style comments. You can manually build and
+This SDK uses [Typedoc](https://typedoc.org/guides/doccomments) doc comments. You can manually build and
 host the API reference from the source files like this:
 
 ```
   $ yarn gendoc
-  $ cd .jsdoc
-  $ python -m SimpleHTTPServer 8005
+  $ cd _docs
+  $ python -m http.server 8005
 ```
 
-Then visit ``http://localhost:8005`` to see the API docs.
+Then visit `http://localhost:8005` to see the API docs.
 
-End-to-end encryption support
-=============================
+# End-to-end encryption support
 
 The SDK supports end-to-end encryption via the Olm and Megolm protocols, using
 [libolm](https://gitlab.matrix.org/matrix-org/olm). It is left up to the
-application to make libolm available, via the ``Olm`` global.
+application to make libolm available, via the `Olm` global.
 
-It is also necessary to call ``await matrixClient.initCrypto()`` after creating a new
-``MatrixClient`` (but **before** calling ``matrixClient.startClient()``) to
+It is also necessary to call `await matrixClient.initCrypto()` after creating a new
+`MatrixClient` (but **before** calling `matrixClient.startClient()`) to
 initialise the crypto layer.
 
-If the ``Olm`` global is not available, the SDK will show a warning, as shown
-below; ``initCrypto()`` will also fail.
+If the `Olm` global is not available, the SDK will show a warning, as shown
+below; `initCrypto()` will also fail.
 
 ```
 Unable to load crypto module: crypto will be disabled: Error: global.Olm is not defined
@@ -332,46 +329,51 @@ specification.
 
 To provide the Olm library in a browser application:
 
- * download the transpiled libolm (from https://packages.matrix.org/npm/olm/).
- * load ``olm.js`` as a ``<script>`` *before* ``browser-matrix.js``.
+-   download the transpiled libolm (from https://packages.matrix.org/npm/olm/).
+-   load `olm.js` as a `<script>` _before_ `browser-matrix.js`.
 
 To provide the Olm library in a node.js application:
 
- * ``yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz``
-   (replace the URL with the latest version you want to use from
+-   `yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz`
+    (replace the URL with the latest version you want to use from
     https://packages.matrix.org/npm/olm/)
- * ``global.Olm = require('olm');`` *before* loading ``matrix-js-sdk``.
+-   `global.Olm = require('olm');` _before_ loading `matrix-js-sdk`.
 
 If you want to package Olm as dependency for your node.js application, you can
-use ``yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz``. If your
-application also works without e2e crypto enabled, add ``--optional`` to mark it
+use `yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz`. If your
+application also works without e2e crypto enabled, add `--optional` to mark it
 as an optional dependency.
 
+# Contributing
 
-Contributing
-============
-*This section is for people who want to modify the SDK. If you just
-want to use this SDK, skip this section.*
+_This section is for people who want to modify the SDK. If you just
+want to use this SDK, skip this section._
 
 First, you need to pull in the right build tools:
+
 ```
  $ yarn install
 ```
 
-Building
---------
+## Building
 
 To build a browser version from scratch when developing::
+
 ```
  $ yarn build
 ```
 
-To run tests (Jasmine)::
+To run tests (Jest):
+
 ```
  $ yarn test
 ```
 
+> **Note**
+> The `sync-browserify.spec.ts` requires a browser build (`yarn build`) in order to pass
+
 To run linting:
+
 ```
  $ yarn lint
 ```

docs/storage-notes.md

@@ -20,19 +20,19 @@ blurrier.
 
 When we are low on disk space overall or near the group limit / origin quota:
 
-* Chrome
-    * Log database may fail to start with AbortError
-    * IndexedDB fails to start for crypto: AbortError in connect from
-      indexeddb-store-worker
-    * When near the quota, QuotaExceededError is used more consistently
-* Firefox
-    * The first error will be QuotaExceededError
-    * Future write attempts will fail with various errors when space is low,
-      including nonsense like "InvalidStateError: A mutation operation was
-      attempted on a database that did not allow mutations."
-    * Once you start getting errors, the DB is effectively wedged in read-only
-      mode
-    * Can revive access if you reopen the DB
+-   Chrome
+    -   Log database may fail to start with AbortError
+    -   IndexedDB fails to start for crypto: AbortError in connect from
+        indexeddb-store-worker
+    -   When near the quota, QuotaExceededError is used more consistently
+-   Firefox
+    -   The first error will be QuotaExceededError
+    -   Future write attempts will fail with various errors when space is low,
+        including nonsense like "InvalidStateError: A mutation operation was
+        attempted on a database that did not allow mutations."
+    -   Once you start getting errors, the DB is effectively wedged in read-only
+        mode
+    -   Can revive access if you reopen the DB
 
 ## Cache Eviction
 
@@ -41,9 +41,9 @@ limited by a single quota, in practice, browsers appear to handle `localStorage`
 separately from the others, so it has a separate quota limit and isn't evicted
 when low on space.
 
-* Chrome, Firefox
-    * IndexedDB for origin deleted
-    * Local Storage remains in place
+-   Chrome, Firefox
+    -   IndexedDB for origin deleted
+    -   Local Storage remains in place
 
 ## Persistent Storage
 
@@ -51,20 +51,20 @@ Storage Standard offers a `navigator.storage.persist` API that can be used to
 request persistent storage that won't be deleted by the browser because of low
 space.
 
-* Chrome
-    * Chrome 75 seems to grant this without any prompt based on [interaction
-      criteria](https://developers.google.com/web/updates/2016/06/persistent-storage)
-* Firefox
-    * Firefox 67 shows a prompt to grant
-    * Reverting persistent seems to require revoking permission _and_ clearing
-      site data
+-   Chrome
+    -   Chrome 75 seems to grant this without any prompt based on [interaction
+        criteria](https://developers.google.com/web/updates/2016/06/persistent-storage)
+-   Firefox
+    -   Firefox 67 shows a prompt to grant
+    -   Reverting persistent seems to require revoking permission _and_ clearing
+        site data
 
 ## Storage Estimation
 
 Storage Standard offers a `navigator.storage.estimate` API to get some clue of
 how much space remains.
 
-* Chrome, Firefox
-    * Can run this at any time to request an estimate of space remaining
-* Firefox
-    * Returns `0` for `usage` if a site is persisted
+-   Chrome, Firefox
+    -   Can run this at any time to request an estimate of space remaining
+-   Firefox
+    -   Returns `0` for `usage` if a site is persisted

examples/browser/README.md

@@ -1,9 +1,10 @@
 To try it out, **you must build the SDK first** and then host this folder:
 
 ```
- $ npm run build
+ $ yarn install
+ $ yarn build
  $ cd examples/browser
- $ python -m SimpleHTTPServer 8003
+ $ python -m http.server 8003
 ```
 
-Then visit ``http://localhost:8003``.
+Then visit `http://localhost:8003`.

examples/browser/browserTest.js

@@ -1,11 +1,7 @@
 console.log("Loading browser sdk");
 
-var client = matrixcs.createClient("https://matrix.org");
-client.publicRooms(function (err, data) {
-    if (err) {
-	   console.error("err %s", JSON.stringify(err));
-       return;
-    }
+var client = matrixcs.createClient({ baseUrl: "https://matrix.org" });
+client.publicRooms().then(function (data) {
     console.log("data %s [...]", JSON.stringify(data).substring(0, 100));
     console.log("Congratulations! The SDK is working on the browser!");
     var result = document.getElementById("result");

examples/browser/index.html

@@ -1,18 +1,17 @@
 <html lang="en">
-<head>
-<title>Test</title>
-<meta charset="utf-8"/>
-<link rel="icon" href="data:,">
-<script src="lib/matrix.js"></script>
-<script src="browserTest.js"></script>
-</head>
-<body>
-	Sanity Testing (check the console) : This example is here to make sure that
-    the SDK works inside a browser. It simply does a GET /publicRooms on
-    matrix.org
-    <br/>
-    You should see a message confirming that the SDK works below:
-    <br/>
-    <div id="result"></div>
-</body>
+    <head>
+        <title>Test</title>
+        <meta charset="utf-8" />
+        <link rel="icon" href="data:," />
+        <script src="lib/matrix.js"></script>
+        <script src="browserTest.js"></script>
+    </head>
+    <body>
+        Sanity Testing (check the console) : This example is here to make sure that the SDK works inside a browser. It
+        simply does a GET /publicRooms on matrix.org
+        <br />
+        You should see a message confirming that the SDK works below:
+        <br />
+        <div id="result"></div>
+    </body>
 </html>

examples/crypto-browser/olm-device-export-import.html

@@ -1,59 +1,60 @@
 <!DOCTYPE html>
 <html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>Test Crypto in Browser</title>
-    <script src="lib/olm.js"></script>
-    <script src="lib/matrix.js"></script>
-</head>
-<body>
-    <h1>Testing export/import of Olm devices in the browser</h1>
-    <ul>
-        <li>
-            Make sure you built the current version of the Matrix JS SDK
-            (<code>yarn build</code>)
-        </li>
-        <li>
-            copy <code>olm.js</code> and <code>olm.wasm</code>
-            from a recent release of Olm (was tested with version 3.1.4)
-            in directory <code>lib/</code>
-        </li>
-        <li>start a local Matrix homeserver (on port 8008, or change the port in the code)</li>
-        <li>Serve this HTML file (e.g. <code>python3 -m http.server</code>) and go to it through your browser</li>
-        <li>
-            in the JS console, do:
-            <pre>
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <meta http-equiv="X-UA-Compatible" content="ie=edge" />
+        <title>Test Crypto in Browser</title>
+        <script src="lib/olm.js"></script>
+        <script src="lib/matrix.js"></script>
+    </head>
+    <body>
+        <h1>Testing export/import of Olm devices in the browser</h1>
+        <ul>
+            <li>Make sure you built the current version of the Matrix JS SDK (<code>yarn build</code>)</li>
+            <li>
+                copy <code>olm.js</code> and <code>olm.wasm</code> from a recent release of Olm (was tested with version
+                3.1.4) in directory <code>lib/</code>
+            </li>
+            <li>start a local Matrix homeserver (on port 8008, or change the port in the code)</li>
+            <li>Serve this HTML file (e.g. <code>python3 -m http.server</code>) and go to it through your browser</li>
+            <li>
+                in the JS console, do:
+                <pre>
 aliceMatrixClient = await newMatrixClient("alice-"+randomHex());
 await aliceMatrixClient.exportDevice();
 await aliceMatrixClient.getAccessToken();
-            </pre>
-        </li>
-        <li>
-            copy the result of <code>exportDevice</code> and <code>getAccessToken</code> somewhere
-            (<strong>not</strong> in a JS variable as it will be destroyed when you refresh the page)
-        </li>
-        <li><strong>refresh the page (F5)</strong> to make sure the client is destroyed</li>
-        <li>
-            Do the following, replacing <code>ALICE_ID</code>
-            with the user ID of Alice (you can find it in the exported data)
-            <pre>
+            </pre
+                >
+            </li>
+            <li>
+                copy the result of <code>exportDevice</code> and <code>getAccessToken</code> somewhere (<strong
+                    >not</strong
+                >
+                in a JS variable as it will be destroyed when you refresh the page)
+            </li>
+            <li><strong>refresh the page (F5)</strong> to make sure the client is destroyed</li>
+            <li>
+                Do the following, replacing <code>ALICE_ID</code>
+                with the user ID of Alice (you can find it in the exported data)
+                <pre>
 bobMatrixClient = await newMatrixClient("bob-"+randomHex());
 roomId = await bobMatrixClient.createEncryptedRoom([ALICE_ID]);
 await bobMatrixClient.sendTextMessage('Hi Alice!', roomId);
-            </pre>
-        </li>
-        <li>Again, <strong>refresh the page (F5)</strong>. You may want to clear your console as well.</li>
-        <li>
-            Now do the following, using the exported data and the access token you saved previously:
-            <pre>
+            </pre
+                >
+            </li>
+            <li>Again, <strong>refresh the page (F5)</strong>. You may want to clear your console as well.</li>
+            <li>
+                Now do the following, using the exported data and the access token you saved previously:
+                <pre>
 aliceMatrixClient = await importMatrixClient(EXPORTED_DATA, ACCESS_TOKEN);
-            </pre>
-        </li>
-        <li>You should see the message sent by Bob printed in the console.</li>
-    </ul>
+            </pre
+                >
+            </li>
+            <li>You should see the message sent by Bob printed in the console.</li>
+        </ul>
 
-    <script src="olm-device-export-import.js"></script>
-</body>
-</html>
+        <script src="olm-device-export-import.js"></script>
+    </body>
+</html>

examples/crypto-browser/olm-device-export-import.js

@@ -1,34 +1,26 @@
 if (!Olm) {
-    console.error(
-        "global.Olm does not seem to be present."
-        + " Did you forget to add olm in the lib/ directory?"
-    );
+    console.error("global.Olm does not seem to be present." + " Did you forget to add olm in the lib/ directory?");
 }
 
-const BASE_URL = 'http://localhost:8008';
-const ROOM_CRYPTO_CONFIG = { algorithm: 'm.megolm.v1.aes-sha2' };
-const PASSWORD = 'password';
+const BASE_URL = "http://localhost:8008";
+const ROOM_CRYPTO_CONFIG = { algorithm: "m.megolm.v1.aes-sha2" };
+const PASSWORD = "password";
 
 // useful to create new usernames
-window.randomHex = () => Math.floor(Math.random() * (10**6)).toString(16);
+window.randomHex = () => Math.floor(Math.random() * 10 ** 6).toString(16);
 
 window.newMatrixClient = async function (username) {
     const registrationClient = matrixcs.createClient(BASE_URL);
 
-    const userRegisterResult = await registrationClient.register(
-      username,
-      PASSWORD,
-      null,
-      { type: 'm.login.dummy' }
-    );
-  
+    const userRegisterResult = await registrationClient.register(username, PASSWORD, null, { type: "m.login.dummy" });
+
     const matrixClient = matrixcs.createClient({
-      baseUrl: BASE_URL,
-      userId: userRegisterResult.user_id,
-      accessToken: userRegisterResult.access_token,
-      deviceId: userRegisterResult.device_id,
-      sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
-      cryptoStore: new matrixcs.MemoryCryptoStore(),
+        baseUrl: BASE_URL,
+        userId: userRegisterResult.user_id,
+        accessToken: userRegisterResult.access_token,
+        deviceId: userRegisterResult.device_id,
+        sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
+        cryptoStore: new matrixcs.MemoryCryptoStore(),
     });
 
     extendMatrixClient(matrixClient);
@@ -36,15 +28,15 @@ window.newMatrixClient = async function (username) {
     await matrixClient.initCrypto();
     await matrixClient.startClient();
     return matrixClient;
-}
+};
 
 window.importMatrixClient = async function (exportedDevice, accessToken) {
     const matrixClient = matrixcs.createClient({
-      baseUrl: BASE_URL,
-      deviceToImport: exportedDevice,
-      accessToken,
-      sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
-      cryptoStore: new matrixcs.MemoryCryptoStore(),
+        baseUrl: BASE_URL,
+        deviceToImport: exportedDevice,
+        accessToken,
+        sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
+        cryptoStore: new matrixcs.MemoryCryptoStore(),
     });
 
     extendMatrixClient(matrixClient);
@@ -52,71 +44,62 @@ window.importMatrixClient = async function (exportedDevice, accessToken) {
     await matrixClient.initCrypto();
     await matrixClient.startClient();
     return matrixClient;
-}
+};
 
 function extendMatrixClient(matrixClient) {
     // automatic join
-    matrixClient.on('RoomMember.membership', async (event, member) => {
-        if (member.membership === 'invite' && member.userId === matrixClient.getUserId()) {
+    matrixClient.on("RoomMember.membership", async (event, member) => {
+        if (member.membership === "invite" && member.userId === matrixClient.getUserId()) {
             await matrixClient.joinRoom(member.roomId);
             // setting up of room encryption seems to be triggered automatically
             // but if we don't wait for it the first messages we send are unencrypted
-            await matrixClient.setRoomEncryption(member.roomId, { algorithm: 'm.megolm.v1.aes-sha2' })
+            await matrixClient.setRoomEncryption(member.roomId, { algorithm: "m.megolm.v1.aes-sha2" });
         }
     });
 
-    matrixClient.onDecryptedMessage = message => {
-        console.log('Got encrypted message: ', message);
-    }
+    matrixClient.onDecryptedMessage = (message) => {
+        console.log("Got encrypted message: ", message);
+    };
 
-    matrixClient.on('Event.decrypted', (event) => {
-        if (event.getType() === 'm.room.message'){
+    matrixClient.on("Event.decrypted", (event) => {
+        if (event.getType() === "m.room.message") {
             matrixClient.onDecryptedMessage(event.getContent().body);
         } else {
-            console.log('decrypted an event of type', event.getType());
+            console.log("decrypted an event of type", event.getType());
             console.log(event);
         }
     });
-  
-    matrixClient.createEncryptedRoom = async function(usersToInvite) {
-        const {
-          room_id: roomId,
-        } = await this.createRoom({
-          visibility: 'private',
-          invite: usersToInvite,
+
+    matrixClient.createEncryptedRoom = async function (usersToInvite) {
+        const { room_id: roomId } = await this.createRoom({
+            visibility: "private",
+            invite: usersToInvite,
         });
 
         // matrixClient.setRoomEncryption() only updates local state
         // but does not send anything to the server
         // (see https://github.com/matrix-org/matrix-js-sdk/issues/905)
         // so we do it ourselves with 'sendStateEvent'
-        await this.sendStateEvent(
-          roomId, 'm.room.encryption', ROOM_CRYPTO_CONFIG,
-        );
-        await this.setRoomEncryption(
-          roomId, ROOM_CRYPTO_CONFIG,
-        );
+        await this.sendStateEvent(roomId, "m.room.encryption", ROOM_CRYPTO_CONFIG);
+        await this.setRoomEncryption(roomId, ROOM_CRYPTO_CONFIG);
 
         // Marking all devices as verified
         let room = this.getRoom(roomId);
-        let members = (await room.getEncryptionTargetMembers()).map(x => x["userId"])
+        let members = (await room.getEncryptionTargetMembers()).map((x) => x["userId"]);
         let memberkeys = await this.downloadKeys(members);
         for (const userId in memberkeys) {
-          for (const deviceId in memberkeys[userId]) {
-            await this.setDeviceVerified(userId, deviceId);
-          }
+            for (const deviceId in memberkeys[userId]) {
+                await this.setDeviceVerified(userId, deviceId);
+            }
         }
 
         return roomId;
-    }
+    };
 
-    matrixClient.sendTextMessage = async function(message, roomId) {
-        return matrixClient.sendMessage(
-            roomId,
-            {
-                body: message,
-                msgtype: 'm.text',
-            }
-        )
-    }
-}
+    matrixClient.sendTextMessage = async function (message, roomId) {
+        return matrixClient.sendMessage(roomId, {
+            body: message,
+            msgtype: "m.text",
+        });
+    };
+}

examples/node/README.md

@@ -1,6 +1,5 @@
 This is a functional terminal app which allows you to see the room list for a user, join rooms, send messages and view room membership lists.
 
-
 To try it out, you will need to edit `app.js` to configure it for your `homeserver`, `access_token` and `user_id`. Then run:
 
 ```
@@ -24,7 +23,7 @@ Room list index commands:
 Room commands:
   '/exit' Return to the room list index.
   '/members' Show the room member list.
-  
+
 $ /enter 2
 
 [2015-06-12 15:14:54] Megan2 <<< herro

examples/node/app.js

@@ -5,7 +5,7 @@ var clc = require("cli-color");
 var matrixClient = sdk.createClient({
     baseUrl: "http://localhost:8008",
     accessToken: myAccessToken,
-    userId: myUserId
+    userId: myUserId,
 });
 
 // Data structures
@@ -14,15 +14,15 @@ var viewingRoom = null;
 var numMessagesToShow = 20;
 
 // Reading from stdin
-var CLEAR_CONSOLE = '\x1B[2J';
+var CLEAR_CONSOLE = "\x1B[2J";
 var readline = require("readline");
 var rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    completer: completer
+    completer: completer,
 });
 rl.setPrompt("$ ");
-rl.on('line', function(line) {
+rl.on("line", function (line) {
     if (line.trim().length === 0) {
         rl.prompt();
         return;
@@ -37,14 +37,11 @@ rl.on('line', function(line) {
         if (line === "/exit") {
             viewingRoom = null;
             printRoomList();
-        }
-        else if (line === "/members") {
+        } else if (line === "/members") {
             printMemberList(viewingRoom);
-        }
-        else if (line === "/roominfo") {
+        } else if (line === "/roominfo") {
             printRoomInfo(viewingRoom);
-        }
-        else if (line === "/resend") {
+        } else if (line === "/resend") {
             // get the oldest not sent event.
             var notSentEvent;
             for (var i = 0; i < viewingRoom.timeline.length; i++) {
@@ -54,76 +51,84 @@ rl.on('line', function(line) {
                 }
             }
             if (notSentEvent) {
-                matrixClient.resendEvent(notSentEvent, viewingRoom).then(function() {
-                    printMessages();
-                    rl.prompt();
-                }, function(err) {
-                    printMessages();
-                    print("/resend Error: %s", err);
-                    rl.prompt();
-                });
+                matrixClient.resendEvent(notSentEvent, viewingRoom).then(
+                    function () {
+                        printMessages();
+                        rl.prompt();
+                    },
+                    function (err) {
+                        printMessages();
+                        print("/resend Error: %s", err);
+                        rl.prompt();
+                    },
+                );
                 printMessages();
                 rl.prompt();
             }
-        }
-        else if (line.indexOf("/more ") === 0) {
+        } else if (line.indexOf("/more ") === 0) {
             var amount = parseInt(line.split(" ")[1]) || 20;
-            matrixClient.scrollback(viewingRoom, amount).then(function(room) {
-                printMessages();
-                rl.prompt();
-            }, function(err) {
-                print("/more Error: %s", err);
-            });
-        }
-        else if (line.indexOf("/invite ") === 0) {
+            matrixClient.scrollback(viewingRoom, amount).then(
+                function (room) {
+                    printMessages();
+                    rl.prompt();
+                },
+                function (err) {
+                    print("/more Error: %s", err);
+                },
+            );
+        } else if (line.indexOf("/invite ") === 0) {
             var userId = line.split(" ")[1].trim();
-            matrixClient.invite(viewingRoom.roomId, userId).then(function() {
-                printMessages();
-                rl.prompt();
-            }, function(err) {
-                print("/invite Error: %s", err);
-            });
-        }
-        else if (line.indexOf("/file ") === 0) {
+            matrixClient.invite(viewingRoom.roomId, userId).then(
+                function () {
+                    printMessages();
+                    rl.prompt();
+                },
+                function (err) {
+                    print("/invite Error: %s", err);
+                },
+            );
+        } else if (line.indexOf("/file ") === 0) {
             var filename = line.split(" ")[1].trim();
             var stream = fs.createReadStream(filename);
-            matrixClient.uploadContent({
-                stream: stream,
-                name: filename
-            }).then(function(url) {
-                var content = {
-                    msgtype: "m.file",
-                    body: filename,
-                    url: JSON.parse(url).content_uri
-                };
-                matrixClient.sendMessage(viewingRoom.roomId, content);
-            });
-        }
-        else {
-            matrixClient.sendTextMessage(viewingRoom.roomId, line).finally(function() {
+            matrixClient
+                .uploadContent({
+                    stream: stream,
+                    name: filename,
+                })
+                .then(function (url) {
+                    var content = {
+                        msgtype: "m.file",
+                        body: filename,
+                        url: JSON.parse(url).content_uri,
+                    };
+                    matrixClient.sendMessage(viewingRoom.roomId, content);
+                });
+        } else {
+            matrixClient.sendTextMessage(viewingRoom.roomId, line).finally(function () {
                 printMessages();
                 rl.prompt();
             });
             // print local echo immediately
             printMessages();
         }
-    }
-    else {
+    } else {
         if (line.indexOf("/join ") === 0) {
             var roomIndex = line.split(" ")[1];
             viewingRoom = roomList[roomIndex];
             if (viewingRoom.getMember(myUserId).membership === "invite") {
                 // join the room first
-                matrixClient.joinRoom(viewingRoom.roomId).then(function(room) {
-                    setRoomList();
-                    viewingRoom = room;
-                    printMessages();
-                    rl.prompt();
-                }, function(err) {
-                    print("/join Error: %s", err);
-                });
-            }
-            else {
+                matrixClient.joinRoom(viewingRoom.roomId).then(
+                    function (room) {
+                        setRoomList();
+                        viewingRoom = room;
+                        printMessages();
+                        rl.prompt();
+                    },
+                    function (err) {
+                        print("/join Error: %s", err);
+                    },
+                );
+            } else {
                 printMessages();
             }
         }
@@ -133,18 +138,18 @@ rl.on('line', function(line) {
 // ==== END User input
 
 // show the room list after syncing.
-matrixClient.on("sync", function(state, prevState, data) {
+matrixClient.on("sync", function (state, prevState, data) {
     switch (state) {
         case "PREPARED":
-          setRoomList();
-          printRoomList();
-          printHelp();
-          rl.prompt();
-        break;
-   }
+            setRoomList();
+            printRoomList();
+            printHelp();
+            rl.prompt();
+            break;
+    }
 });
 
-matrixClient.on("Room", function() {
+matrixClient.on("Room", function () {
     setRoomList();
     if (!viewingRoom) {
         printRoomList();
@@ -153,7 +158,7 @@ matrixClient.on("Room", function() {
 });
 
 // print incoming messages.
-matrixClient.on("Room.timeline", function(event, room, toStartOfTimeline) {
+matrixClient.on("Room.timeline", function (event, room, toStartOfTimeline) {
     if (toStartOfTimeline) {
         return; // don't print paginated results
     }
@@ -165,20 +170,19 @@ matrixClient.on("Room.timeline", function(event, room, toStartOfTimeline) {
 
 function setRoomList() {
     roomList = matrixClient.getRooms();
-    roomList.sort(function(a,b) {
+    roomList.sort(function (a, b) {
         // < 0 = a comes first (lower index) - we want high indexes = newer
-        var aMsg = a.timeline[a.timeline.length-1];
+        var aMsg = a.timeline[a.timeline.length - 1];
         if (!aMsg) {
             return -1;
         }
-        var bMsg = b.timeline[b.timeline.length-1];
+        var bMsg = b.timeline[b.timeline.length - 1];
         if (!bMsg) {
             return 1;
         }
         if (aMsg.getTs() > bMsg.getTs()) {
             return 1;
-        }
-        else if (aMsg.getTs() < bMsg.getTs()) {
+        } else if (aMsg.getTs() < bMsg.getTs()) {
             return -1;
         }
         return 0;
@@ -189,16 +193,15 @@ function printRoomList() {
     print(CLEAR_CONSOLE);
     print("Room List:");
     var fmts = {
-        "invite": clc.cyanBright,
-        "leave": clc.blackBright
+        invite: clc.cyanBright,
+        leave: clc.blackBright,
     };
     for (var i = 0; i < roomList.length; i++) {
-        var msg = roomList[i].timeline[roomList[i].timeline.length-1];
+        var msg = roomList[i].timeline[roomList[i].timeline.length - 1];
         var dateStr = "---";
         var fmt;
         if (msg) {
-            dateStr = new Date(msg.getTs()).toISOString().replace(
-                /T/, ' ').replace(/\..+/, '');
+            dateStr = new Date(msg.getTs()).toISOString().replace(/T/, " ").replace(/\..+/, "");
         }
         var myMembership = roomList[i].getMyMembership();
         if (myMembership) {
@@ -207,9 +210,10 @@ function printRoomList() {
         var roomName = fixWidth(roomList[i].name, 25);
         print(
             "[%s] %s (%s members)  %s",
-            i, fmt ? fmt(roomName) : roomName,
+            i,
+            fmt ? fmt(roomName) : roomName,
             roomList[i].getJoinedMembers().length,
-            dateStr
+            dateStr,
         );
     }
 }
@@ -230,12 +234,12 @@ function printHelp() {
 }
 
 function completer(line) {
-    var completions = [
-        "/help", "/join ", "/exit", "/members", "/more ", "/resend", "/invite"
-    ];
-    var hits = completions.filter(function(c) { return c.indexOf(line) == 0 });
+    var completions = ["/help", "/join ", "/exit", "/members", "/more ", "/resend", "/invite"];
+    var hits = completions.filter(function (c) {
+        return c.indexOf(line) == 0;
+    });
     // show all completions if none found
-    return [hits.length ? hits : completions, line]
+    return [hits.length ? hits : completions, line];
 }
 
 function printMessages() {
@@ -252,14 +256,14 @@ function printMessages() {
 
 function printMemberList(room) {
     var fmts = {
-        "join": clc.green,
-        "ban": clc.red,
-        "invite": clc.blue,
-        "leave": clc.blackBright
+        join: clc.green,
+        ban: clc.red,
+        invite: clc.blue,
+        leave: clc.blackBright,
     };
     var members = room.currentState.getMembers();
     // sorted based on name.
-    members.sort(function(a, b) {
+    members.sort(function (a, b) {
         if (a.name > b.name) {
             return -1;
         }
@@ -268,21 +272,24 @@ function printMemberList(room) {
         }
         return 0;
     });
-    print("Membership list for room \"%s\"", room.name);
+    print('Membership list for room "%s"', room.name);
     print(new Array(room.name.length + 28).join("-"));
-    room.currentState.getMembers().forEach(function(member) {
+    room.currentState.getMembers().forEach(function (member) {
         if (!member.membership) {
             return;
         }
-        var fmt = fmts[member.membership] || function(a){return a;};
-        var membershipWithPadding = (
-            member.membership + new Array(10 - member.membership.length).join(" ")
-        );
+        var fmt =
+            fmts[member.membership] ||
+            function (a) {
+                return a;
+            };
+        var membershipWithPadding = member.membership + new Array(10 - member.membership.length).join(" ");
         print(
-            "%s"+fmt(" :: ")+"%s"+fmt(" (")+"%s"+fmt(")"),
-            membershipWithPadding, member.name,
-            (member.userId === myUserId ? "Me" : member.userId),
-            fmt
+            "%s" + fmt(" :: ") + "%s" + fmt(" (") + "%s" + fmt(")"),
+            membershipWithPadding,
+            member.name,
+            member.userId === myUserId ? "Me" : member.userId,
+            fmt,
         );
     });
 }
@@ -292,38 +299,31 @@ function printRoomInfo(room) {
     var eTypeHeader = "    Event Type(state_key)    ";
     var sendHeader = "        Sender        ";
     // pad content to 100
-    var restCount = (
-        100 - "Content".length - " | ".length - " | ".length -
-        eTypeHeader.length - sendHeader.length
-    );
-    var padSide = new Array(Math.floor(restCount/2)).join(" ");
+    var restCount = 100 - "Content".length - " | ".length - " | ".length - eTypeHeader.length - sendHeader.length;
+    var padSide = new Array(Math.floor(restCount / 2)).join(" ");
     var contentHeader = padSide + "Content" + padSide;
-    print(eTypeHeader+sendHeader+contentHeader);
+    print(eTypeHeader + sendHeader + contentHeader);
     print(new Array(100).join("-"));
-    eventMap.keys().forEach(function(eventType) {
-        if (eventType === "m.room.member") { return; } // use /members instead.
+    eventMap.keys().forEach(function (eventType) {
+        if (eventType === "m.room.member") {
+            return;
+        } // use /members instead.
         var eventEventMap = eventMap.get(eventType);
-        eventEventMap.keys().forEach(function(stateKey) {
-            var typeAndKey = eventType + (
-                stateKey.length > 0 ? "("+stateKey+")" : ""
-            );
+        eventEventMap.keys().forEach(function (stateKey) {
+            var typeAndKey = eventType + (stateKey.length > 0 ? "(" + stateKey + ")" : "");
             var typeStr = fixWidth(typeAndKey, eTypeHeader.length);
             var event = eventEventMap.get(stateKey);
             var sendStr = fixWidth(event.getSender(), sendHeader.length);
-            var contentStr = fixWidth(
-                JSON.stringify(event.getContent()), contentHeader.length
-            );
-            print(typeStr+" | "+sendStr+" | "+contentStr);
+            var contentStr = fixWidth(JSON.stringify(event.getContent()), contentHeader.length);
+            print(typeStr + " | " + sendStr + " | " + contentStr);
         });
-    })
+    });
 }
 
 function printLine(event) {
     var fmt;
     var name = event.sender ? event.sender.name : event.getSender();
-    var time = new Date(
-        event.getTs()
-    ).toISOString().replace(/T/, ' ').replace(/\..+/, '');
+    var time = new Date(event.getTs()).toISOString().replace(/T/, " ").replace(/\..+/, "");
     var separator = "<<<";
     if (event.getSender() === myUserId) {
         name = "Me";
@@ -331,8 +331,7 @@ function printLine(event) {
         if (event.status === sdk.EventStatus.SENDING) {
             separator = "...";
             fmt = clc.xterm(8);
-        }
-        else if (event.status === sdk.EventStatus.NOT_SENT) {
+        } else if (event.status === sdk.EventStatus.NOT_SENT) {
             separator = " x ";
             fmt = clc.redBright;
         }
@@ -341,69 +340,58 @@ function printLine(event) {
 
     var maxNameWidth = 15;
     if (name.length > maxNameWidth) {
-        name = name.slice(0, maxNameWidth-1) + "\u2026";
+        name = name.slice(0, maxNameWidth - 1) + "\u2026";
     }
 
     if (event.getType() === "m.room.message") {
         body = event.getContent().body;
-    }
-    else if (event.isState()) {
+    } else if (event.isState()) {
         var stateName = event.getType();
         if (event.getStateKey().length > 0) {
-            stateName += " ("+event.getStateKey()+")";
+            stateName += " (" + event.getStateKey() + ")";
         }
-        body = (
-            "[State: "+stateName+" updated to: "+JSON.stringify(event.getContent())+"]"
-        );
+        body = "[State: " + stateName + " updated to: " + JSON.stringify(event.getContent()) + "]";
         separator = "---";
         fmt = clc.xterm(249).italic;
-    }
-    else {
+    } else {
         // random message event
-        body = (
-            "[Message: "+event.getType()+" Content: "+JSON.stringify(event.getContent())+"]"
-        );
+        body = "[Message: " + event.getType() + " Content: " + JSON.stringify(event.getContent()) + "]";
         separator = "---";
         fmt = clc.xterm(249).italic;
     }
     if (fmt) {
-        print(
-            "[%s] %s %s %s", time, name, separator, body, fmt
-        );
-    }
-    else {
+        print("[%s] %s %s %s", time, name, separator, body, fmt);
+    } else {
         print("[%s] %s %s %s", time, name, separator, body);
     }
 }
 
 function print(str, formatter) {
-    if (typeof arguments[arguments.length-1] === "function") {
+    if (typeof arguments[arguments.length - 1] === "function") {
         // last arg is the formatter so get rid of it and use it on each
         // param passed in but not the template string.
         var newArgs = [];
         var i = 0;
-        for (i=0; i<arguments.length-1; i++) {
+        for (i = 0; i < arguments.length - 1; i++) {
             newArgs.push(arguments[i]);
         }
-        var fmt = arguments[arguments.length-1];
-        for (i=0; i<newArgs.length; i++) {
+        var fmt = arguments[arguments.length - 1];
+        for (i = 0; i < newArgs.length; i++) {
             newArgs[i] = fmt(newArgs[i]);
         }
         console.log.apply(console.log, newArgs);
-    }
-    else {
+    } else {
         console.log.apply(console.log, arguments);
     }
 }
 
 function fixWidth(str, len) {
     if (str.length > len) {
-        return str.substring(0, len-2) + "\u2026";
-    }
-    else if (str.length < len) {
+        return str.substring(0, len - 2) + "\u2026";
+    } else if (str.length < len) {
         return str + new Array(len - str.length).join(" ");
     }
     return str;
 }
 
-matrixClient.startClient(numMessagesToShow);  // messages for each room.
+matrixClient.startClient(numMessagesToShow); // messages for each room.

examples/node/package.json

@@ -1,14 +1,14 @@
 {
-  "name": "example-app",
-  "version": "0.0.0",
-  "description": "",
-  "main": "app.js",
-  "scripts": {
-    "preinstall": "npm install ../.."
-  },
-  "author": "",
-  "license": "Apache 2.0",
-  "dependencies": {
-    "cli-color": "^1.0.0"
-  }
+    "name": "example-app",
+    "version": "0.0.0",
+    "description": "",
+    "main": "app.js",
+    "scripts": {
+        "preinstall": "npm install ../.."
+    },
+    "author": "",
+    "license": "Apache 2.0",
+    "dependencies": {
+        "cli-color": "^1.0.0"
+    }
 }

examples/voip/README.md

@@ -6,4 +6,4 @@ To try it out, **you must build the SDK first** and then host this folder:
  $ python -m SimpleHTTPServer 8003
 ```
 
-Then visit ``http://localhost:8003``.
+Then visit `http://localhost:8003`.

examples/voip/browserTest.js

@@ -9,7 +9,7 @@ const client = matrixcs.createClient({
     baseUrl: BASE_URL,
     accessToken: TOKEN,
     userId: USER_ID,
-    deviceId: DEVICE_ID
+    deviceId: DEVICE_ID,
 });
 let call;
 
@@ -21,18 +21,16 @@ function disableButtons(place, answer, hangup) {
 
 function addListeners(call) {
     let lastError = "";
-    call.on("hangup", function() {
+    call.on("hangup", function () {
         disableButtons(false, true, true);
-        document.getElementById("result").innerHTML = (
-            "<p>Call ended. Last error: "+lastError+"</p>"
-        );
+        document.getElementById("result").innerHTML = "<p>Call ended. Last error: " + lastError + "</p>";
     });
-    call.on("error", function(err) {
+    call.on("error", function (err) {
         lastError = err.message;
         call.hangup();
         disableButtons(false, true, true);
     });
-    call.on("feeds_changed", function(feeds) {
+    call.on("feeds_changed", function (feeds) {
         const localFeed = feeds.find((feed) => feed.isLocal());
         const remoteFeed = feeds.find((feed) => !feed.isLocal());
 
@@ -51,33 +49,38 @@ function addListeners(call) {
     });
 }
 
-window.onload = function() {
+window.onload = function () {
     document.getElementById("result").innerHTML = "<p>Please wait. Syncing...</p>";
-    document.getElementById("config").innerHTML = "<p>" +
-        "Homeserver: <code>"+BASE_URL+"</code><br/>"+
-        "Room: <code>"+ROOM_ID+"</code><br/>"+
-        "User: <code>"+USER_ID+"</code><br/>"+
+    document.getElementById("config").innerHTML =
+        "<p>" +
+        "Homeserver: <code>" +
+        BASE_URL +
+        "</code><br/>" +
+        "Room: <code>" +
+        ROOM_ID +
+        "</code><br/>" +
+        "User: <code>" +
+        USER_ID +
+        "</code><br/>" +
         "</p>";
     disableButtons(true, true, true);
 };
 
-client.on("sync", function(state, prevState, data) {
+client.on("sync", function (state, prevState, data) {
     switch (state) {
         case "PREPARED":
-          syncComplete();
-        break;
-   }
+            syncComplete();
+            break;
+    }
 });
 
 function syncComplete() {
     document.getElementById("result").innerHTML = "<p>Ready for calls.</p>";
     disableButtons(false, true, true);
 
-    document.getElementById("call").onclick = function() {
+    document.getElementById("call").onclick = function () {
         console.log("Placing call...");
-        call = matrixcs.createNewMatrixCall(
-            client, ROOM_ID
-        );
+        call = matrixcs.createNewMatrixCall(client, ROOM_ID);
         console.log("Call => %s", call);
         addListeners(call);
         call.placeVideoCall();
@@ -85,14 +88,14 @@ function syncComplete() {
         disableButtons(true, true, false);
     };
 
-    document.getElementById("hangup").onclick = function() {
+    document.getElementById("hangup").onclick = function () {
         console.log("Hanging up call...");
         console.log("Call => %s", call);
         call.hangup();
         document.getElementById("result").innerHTML = "<p>Hungup call.</p>";
     };
 
-    document.getElementById("answer").onclick = function() {
+    document.getElementById("answer").onclick = function () {
         console.log("Answering call...");
         console.log("Call => %s", call);
         call.answer();
@@ -100,7 +103,7 @@ function syncComplete() {
         document.getElementById("result").innerHTML = "<p>Answered call.</p>";
     };
 
-    client.on("Call.incoming", function(c) {
+    client.on("Call.incoming", function (c) {
         console.log("Call ringing");
         disableButtons(true, false, false);
         document.getElementById("result").innerHTML = "<p>Incoming call...</p>";

examples/voip/index.html

@@ -1,25 +1,23 @@
 <html>
+    <head>
+        <title>VoIP Test</title>
+        <script src="lib/matrix.js"></script>
+        <script src="browserTest.js"></script>
+    </head>
 
-<head>
-    <title>VoIP Test</title>
-    <script src="lib/matrix.js"></script>
-    <script src="browserTest.js"></script>
-</head>
-
-<body>
-    You can place and receive calls with this example. Make sure to edit the
-    constants in <code>browserTest.js</code> first.
-    <div id="config"></div>
-    <div id="result"></div>
-    <button id="call">Place Call</button>
-    <button id="answer">Answer Call</button>
-    <button id="hangup">Hangup Call</button>
-    <div id="videoBackground" class="video-background">
-        <video class="video-element" id="local"></video>
-        <video class="video-element" id="remote"></video>
-    </div>
-</body>
-
+    <body>
+        You can place and receive calls with this example. Make sure to edit the constants in
+        <code>browserTest.js</code> first.
+        <div id="config"></div>
+        <div id="result"></div>
+        <button id="call">Place Call</button>
+        <button id="answer">Answer Call</button>
+        <button id="hangup">Hangup Call</button>
+        <div id="videoBackground" class="video-background">
+            <video class="video-element" id="local"></video>
+            <video class="video-element" id="remote"></video>
+        </div>
+    </body>
 </html>
 
 <style>
@@ -31,4 +29,4 @@
     .video-element {
         height: 100%;
     }
-</style>
+</style>

jsdoc.json

@@ -1,30 +0,0 @@
-{
-  "tags": {
-    "allowUnknownTags": true
-  },
-  "plugins": [
-    "node_modules/better-docs/category",
-    "node_modules/better-docs/typescript"
-  ],
-  "source": {
-    "include": [
-      "src"
-    ],
-    "includePattern": ".(ts|js)$"
-  },
-  "opts": {
-    "encoding": "utf8",
-    "destination": ".jsdoc",
-    "readme": "README.md",
-    "recurse": true,
-    "verbose": true,
-    "template": "node_modules/docdash"
-  },
-  "docdash": {
-    "static": true,
-    "private": false,
-    "search": true,
-    "collapse": true,
-    "typedefs": true
-  }
-}

package.json

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

post-release.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+#
+# Script to perform a post-release steps of matrix-js-sdk.
+#
+# Requires:
+#   jq; install from your distribution's package manager (https://stedolan.github.io/jq/)
+
+set -e
+
+jq --version > /dev/null || (echo "jq is required: please install it"; kill $$)
+
+if [ "$(git branch -lr | grep origin/develop -c)" -ge 1 ]; then
+    # When merging to develop, we need revert the `main` and `typings` fields if we adjusted them previously.
+    for i in main typings
+    do
+        # If a `lib` prefixed value is present, it means we adjusted the field
+        # earlier at publish time, so we should revert it now.
+        if [ "$(jq -r ".matrix_lib_$i" package.json)" != "null" ]; then
+            # If there's a `src` prefixed value, use that, otherwise delete.
+            # This is used to delete the `typings` field and reset `main` back
+            # to the TypeScript source.
+            src_value=$(jq -r ".matrix_src_$i" package.json)
+            if [ "$src_value" != "null" ]; then
+                jq ".$i = .matrix_src_$i" package.json > package.json.new && mv package.json.new package.json && yarn prettier --write package.json
+            else
+                jq "del(.$i)" package.json > package.json.new && mv package.json.new package.json && yarn prettier --write package.json
+            fi
+        fi
+    done
+
+    if [ -n "$(git ls-files --modified package.json)" ]; then
+        echo "Committing develop package.json"
+        git commit package.json -m "Resetting package fields for development"
+    fi
+
+    git push origin develop
+fi

release.sh

@@ -3,19 +3,16 @@
 # Script to perform a release of matrix-js-sdk and downstream projects.
 #
 # Requires:
-#   github-changelog-generator; install via:
-#     pip install git+https://github.com/matrix-org/github-changelog-generator.git
 #   jq; install from your distribution's package manager (https://stedolan.github.io/jq/)
 #   hub; install via brew (macOS) or source/pre-compiled binaries (debian) (https://github.com/github/hub) - Tested on v2.2.9
-#   npm; typically installed by Node.js
 #   yarn; install via brew (macOS) or similar (https://yarnpkg.com/docs/install/)
 #
-# Note: this script is also used to release matrix-react-sdk and element-web.
+# Note: this script is also used to release matrix-react-sdk, element-web, and element-desktop.
 
 set -e
 
 jq --version > /dev/null || (echo "jq is required: please install it"; kill $$)
-if [[ `command -v hub` ]] && [[ `hub --version` =~ hub[[:space:]]version[[:space:]]([0-9]*).([0-9]*) ]]; then
+if [[ $(command -v hub) ]] && [[ $(hub --version) =~ hub[[:space:]]version[[:space:]]([0-9]*).([0-9]*) ]]; then
     HUB_VERSION_MAJOR=${BASH_REMATCH[1]}
     HUB_VERSION_MINOR=${BASH_REMATCH[2]}
     if [[ $HUB_VERSION_MAJOR -lt 2 ]] || [[ $HUB_VERSION_MAJOR -eq 2 && $HUB_VERSION_MINOR -lt 5 ]]; then
@@ -26,7 +23,6 @@ else
     echo "hub is required: please install it"
     exit
 fi
-npm --version > /dev/null || (echo "npm is required: please install it"; kill $$)
 yarn --version > /dev/null || (echo "yarn is required: please install it"; kill $$)
 
 USAGE="$0 [-x] [-c changelog_file] vX.Y.Z"
@@ -37,17 +33,9 @@ $USAGE
 
     -c changelog_file:  specify name of file containing changelog
     -x:                 skip updating the changelog
-    -n:                 skip publish to NPM
 EOF
 }
 
-ret=0
-cat package.json | jq '.dependencies[]' | grep -q '#develop' || ret=$?
-if [ "$ret" -eq 0 ]; then
-    echo "package.json contains develop dependencies. Refusing to release."
-    exit
-fi
-
 if ! git diff-index --quiet --cached HEAD; then
     echo "this git checkout has staged (uncommitted) changes. Refusing to release."
     exit
@@ -59,10 +47,8 @@ if ! git diff-files --quiet; then
 fi
 
 skip_changelog=
-skip_npm=
 changelog_file="CHANGELOG.md"
-expected_npm_user="matrixdotorg"
-while getopts hc:u:xzn f; do
+while getopts hc:x f; do
     case $f in
         h)
             help
@@ -74,21 +60,70 @@ while getopts hc:u:xzn f; do
         x)
             skip_changelog=1
             ;;
-        n)
-            skip_npm=1
-            ;;
-        u)
-            expected_npm_user="$OPTARG"
-            ;;
     esac
 done
-shift `expr $OPTIND - 1`
+shift $(expr $OPTIND - 1)
 
 if [ $# -ne 1 ]; then
     echo "Usage: $USAGE" >&2
     exit 1
 fi
 
+function check_dependency {
+    local depver=$(cat package.json | jq -r .dependencies[\"$1\"])
+    if [ "$depver" == "null" ]; then return 0; fi
+
+    echo "Checking version of $1..."
+    local latestver=$(yarn info -s "$1" dist-tags.next)
+    if [ "$depver" != "$latestver" ]
+    then
+        echo "The latest version of $1 is $latestver but package.json depends on $depver."
+        echo -n "Type 'u' to auto-upgrade, 'c' to continue anyway, or 'a' to abort:"
+        read resp
+        if [ "$resp" != "u" ] && [ "$resp" != "c" ]
+        then
+            echo "Aborting."
+            exit 1
+        fi
+        if [ "$resp" == "u" ]
+        then
+            echo "Upgrading $1 to $latestver..."
+            yarn add -E "$1@$latestver"
+            git add -u
+            git commit -m "Upgrade $1 to $latestver"
+        fi
+    fi
+}
+
+function reset_dependency {
+    local depver=$(cat package.json | jq -r .dependencies[\"$1\"])
+    if [ "$depver" == "null" ]; then return 0; fi
+
+    echo "Resetting $1 to develop branch..."
+    yarn add "github:matrix-org/$1#develop"
+    git add -u
+    git commit -m "Reset $1 back to develop branch"
+}
+
+has_subprojects=0
+if [ -f release_config.yaml ]; then
+    subprojects=$(cat release_config.yaml | python -c "import yaml; import sys; print(' '.join(list(yaml.load(sys.stdin)['subprojects'].keys())))" 2> /dev/null)
+    if [ "$?" -eq 0 ]; then
+        has_subprojects=1
+        echo "Checking subprojects for upgrades"
+        for proj in $subprojects; do
+            check_dependency "$proj"
+        done
+    fi
+fi
+
+ret=0
+cat package.json | jq '.dependencies[]' | grep -q '#develop' || ret=$?
+if [ "$ret" -eq 0 ]; then
+    echo "package.json contains develop dependencies. Refusing to release."
+    exit
+fi
+
 # We use Git branch / commit dependencies for some packages, and Yarn seems
 # to have a hard time getting that right. See also
 # https://github.com/yarnpkg/yarn/issues/4734. As a workaround, we clean the
@@ -97,20 +132,9 @@ yarn cache clean
 # Ensure all dependencies are updated
 yarn install --ignore-scripts --pure-lockfile
 
-# Login and publish continues to use `npm`, as it seems to have more clearly
-# defined options and semantics than `yarn` for writing to the registry.
-if [ -z "$skip_npm" ]; then
-    actual_npm_user=`npm whoami`;
-    if [ $expected_npm_user != $actual_npm_user ]; then
-        echo "you need to be logged into npm as $expected_npm_user, but you are logged in as $actual_npm_user" >&2
-        exit 1
-    fi
-fi
-
 # ignore leading v on release
 release="${1#v}"
 tag="v${release}"
-rel_branch="release-$tag"
 
 prerelease=0
 # We check if this build is a prerelease by looking to
@@ -121,20 +145,11 @@ echo $release | grep -q '-' && prerelease=1
 
 if [ $prerelease -eq 1 ]; then
     echo Making a PRE-RELEASE
+else
+    read -p "Making a FINAL RELEASE, press enter to continue " REPLY
 fi
 
-# we might already be on the release branch, in which case, yay
-# If we're on any branch starting with 'release', we don't create
-# a separate release branch (this allows us to use the same
-# release branch for releases and release candidates).
-curbranch=$(git symbolic-ref --short HEAD)
-if [[ "$curbranch" != release* ]]; then
-    echo "Creating release branch"
-    git checkout -b "$rel_branch"
-else
-    echo "Using current branch ($curbranch) for release"
-    rel_branch=$curbranch
-fi
+rel_branch=$(git symbolic-ref --short HEAD)
 
 if [ -z "$skip_changelog" ]; then
     echo "Generating changelog"
@@ -146,8 +161,8 @@ if [ -z "$skip_changelog" ]; then
         git commit "$changelog_file" -m "Prepare changelog for $tag"
     fi
 fi
-latest_changes=`mktemp`
-cat "${changelog_file}" | `dirname $0`/scripts/changelog_head.py > "${latest_changes}"
+latest_changes=$(mktemp)
+cat "${changelog_file}" | "$(dirname "$0")/scripts/changelog_head.py" > "${latest_changes}"
 
 set -x
 
@@ -169,12 +184,12 @@ for i in main typings
 do
     lib_value=$(jq -r ".matrix_lib_$i" package.json)
     if [ "$lib_value" != "null" ]; then
-        jq ".$i = .matrix_lib_$i" package.json > package.json.new && mv package.json.new package.json
+        jq ".$i = .matrix_lib_$i" package.json > package.json.new && mv package.json.new package.json && yarn prettier --write package.json
     fi
 done
 
 # commit yarn.lock if it exists, is versioned, and is modified
-if [[ -f yarn.lock && `git status --porcelain yarn.lock | grep '^ M'` ]];
+if [[ -f yarn.lock && $(git status --porcelain yarn.lock | grep '^ M') ]];
 then
     pkglock='yarn.lock'
 else
@@ -186,7 +201,7 @@ git commit package.json $pkglock -m "$tag"
 # figure out if we should be signing this release
 signing_id=
 if [ -f release_config.yaml ]; then
-    result=`cat release_config.yaml | python -c "import yaml; import sys; print yaml.load(sys.stdin)['signing_id']" 2> /dev/null || true`
+    result=$(cat release_config.yaml | python -c "import yaml; import sys; print(yaml.load(sys.stdin)['signing_id'])" 2> /dev/null || true)
     if [ "$?" -eq 0 ]; then
         signing_id=$result
     fi
@@ -204,8 +219,8 @@ assets=''
 dodist=0
 jq -e .scripts.dist package.json 2> /dev/null || dodist=$?
 if [ $dodist -eq 0 ]; then
-    projdir=`pwd`
-    builddir=`mktemp -d 2>/dev/null || mktemp -d -t 'mytmpdir'`
+    projdir=$(pwd)
+    builddir=$(mktemp -d 2>/dev/null || mktemp -d -t 'mytmpdir')
     echo "Building distribution copy in $builddir"
     pushd "$builddir"
     git clone "$projdir" .
@@ -230,7 +245,7 @@ fi
 if [ -n "$signing_id" ]; then
     # make a signed tag
     # gnupg seems to fail to get the right tty device unless we set it here
-    GIT_COMMITTER_EMAIL="$signing_id" GPG_TTY=`tty` git tag -u "$signing_id" -F "${latest_changes}" "$tag"
+    GIT_COMMITTER_EMAIL="$signing_id" GPG_TTY=$(tty) git tag -u "$signing_id" -F "${latest_changes}" "$tag"
 else
     git tag -a -F "${latest_changes}" "$tag"
 fi
@@ -296,7 +311,7 @@ if [ $prerelease -eq 1 ]; then
     hubflags='-p'
 fi
 
-release_text=`mktemp`
+release_text=$(mktemp)
 echo "$tag" > "${release_text}"
 echo >> "${release_text}"
 cat "${latest_changes}" >> "${release_text}"
@@ -308,19 +323,6 @@ fi
 rm "${release_text}"
 rm "${latest_changes}"
 
-# Login and publish continues to use `npm`, as it seems to have more clearly
-# defined options and semantics than `yarn` for writing to the registry.
-# Tag both releases and prereleases as `next` so the last stable release remains
-# the default.
-if [ -z "$skip_npm" ]; then
-    npm publish --tag next
-    if [ $prerelease -eq 0 ]; then
-        # For a release, also add the default `latest` tag.
-        package=$(cat package.json | jq -er .name)
-        npm dist-tag add "$package@$release" latest
-    fi
-fi
-
 # if it is a pre-release, leave it on the release branch for now.
 if [ $prerelease -eq 1 ]; then
     git checkout "$rel_branch"
@@ -337,34 +339,19 @@ git merge "$rel_branch" --no-edit
 git push origin master
 
 # finally, merge master back onto develop (if it exists)
-if [ $(git branch -lr | grep origin/develop -c) -ge 1 ]; then
+if [ "$(git branch -lr | grep origin/develop -c)" -ge 1 ]; then
     git checkout develop
     git pull
     git merge master --no-edit
-
-    # When merging to develop, we need revert the `main` and `typings` fields if
-    # we adjusted them previously.
-    for i in main typings
-    do
-        # If a `lib` prefixed value is present, it means we adjusted the field
-        # earlier at publish time, so we should revert it now.
-        if [ "$(jq -r ".matrix_lib_$i" package.json)" != "null" ]; then
-            # If there's a `src` prefixed value, use that, otherwise delete.
-            # This is used to delete the `typings` field and reset `main` back
-            # to the TypeScript source.
-            src_value=$(jq -r ".matrix_src_$i" package.json)
-            if [ "$src_value" != "null" ]; then
-                jq ".$i = .matrix_src_$i" package.json > package.json.new && mv package.json.new package.json
-            else
-                jq "del(.$i)" package.json > package.json.new && mv package.json.new package.json
-            fi
-        fi
-    done
-
-    if [ -n "$(git ls-files --modified package.json)" ]; then
-        echo "Committing develop package.json"
-        git commit package.json -m "Resetting package fields for development"
-    fi
-
+    git push origin develop
+fi
+
+[ -x ./post-release.sh ] && ./post-release.sh
+
+if [ $has_subprojects -eq 1 ] && [ $prerelease -eq 0 ]; then
+    echo "Resetting subprojects to develop"
+    for proj in $subprojects; do
+        reset_dependency "$proj"
+    done
     git push origin develop
 fi

renovate.json

@@ -1,16 +0,0 @@
-{
-    "extends": [
-        "config:base",
-        ":dependencyDashboardApproval"
-    ],
-    "labels": ["T-Task", "Dependencies"],
-    "lockFileMaintenance": { "enabled": true },
-    "groupName": "all",
-    "packageRules": [{
-        "matchFiles": ["package.json"],
-        "rangeStrategy": "update-lockfile"
-    }],
-    "platformAutomerge": true,
-    "automerge": true,
-    "automergeType": "pr"
-}

scripts/switch_package_to_release.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+const fsProm = require("fs/promises");
+
+const PKGJSON = "package.json";
+
+async function main() {
+    const pkgJson = JSON.parse(await fsProm.readFile(PKGJSON, "utf8"));
+    for (const field of ["main", "typings"]) {
+        if (pkgJson["matrix_lib_" + field] !== undefined) {
+            pkgJson[field] = pkgJson["matrix_lib_" + field];
+        }
+    }
+    await fsProm.writeFile(PKGJSON, JSON.stringify(pkgJson, null, 2));
+}
+
+main();

sonar-project.properties

@@ -11,6 +11,6 @@ sonar.exclusions=docs,examples,git-hooks
 sonar.typescript.tsconfigPath=./tsconfig.json
 sonar.javascript.lcov.reportPaths=coverage/lcov.info
 sonar.coverage.exclusions=spec/**/*
-sonar.testExecutionReportPaths=coverage/test-report.xml
+sonar.testExecutionReportPaths=coverage/jest-sonar-report.xml
 
 sonar.lang.patterns.ts=**/*.ts,**/*.tsx

spec/MockStorageApi.ts

@@ -1,6 +1,6 @@
 /*
 Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
+Copyright 2019, 2022 The Matrix.org Foundation C.I.C.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,31 +17,32 @@ limitations under the License.
 
 /**
  * A mock implementation of the webstorage api
- * @constructor
  */
-export function MockStorageApi() {
-    this.data = {};
-    this.keys = [];
-    this.length = 0;
-}
+export class MockStorageApi {
+    public data: Record<string, string> = {};
+    public keys: string[] = [];
+    public length = 0;
 
-MockStorageApi.prototype = {
-    setItem: function(k, v) {
+    public setItem(k: string, v: string): void {
         this.data[k] = v;
-        this._recalc();
-    },
-    getItem: function(k) {
+        this.recalc();
+    }
+
+    public getItem(k: string): string | null {
         return this.data[k] || null;
-    },
-    removeItem: function(k) {
+    }
+
+    public removeItem(k: string): void {
         delete this.data[k];
-        this._recalc();
-    },
-    key: function(index) {
+        this.recalc();
+    }
+
+    public key(index: number): string {
         return this.keys[index];
-    },
-    _recalc: function() {
-        const keys = [];
+    }
+
+    private recalc(): void {
+        const keys: string[] = [];
         for (const k in this.data) {
             if (!this.data.hasOwnProperty(k)) {
                 continue;
@@ -50,6 +51,5 @@ MockStorageApi.prototype = {
         }
         this.keys = keys;
         this.length = keys.length;
-    },
-};
-
+    }
+}

spec/TestClient.ts

@@ -17,21 +17,20 @@ limitations under the License.
 */
 
 // load olm before the sdk if possible
-import './olm-loader';
+import "./olm-loader";
 
-import MockHttpBackend from 'matrix-mock-request';
+import MockHttpBackend from "matrix-mock-request";
 
-import { LocalStorageCryptoStore } from '../src/crypto/store/localStorage-crypto-store';
-import { logger } from '../src/logger';
+import { LocalStorageCryptoStore } from "../src/crypto/store/localStorage-crypto-store";
+import { logger } from "../src/logger";
 import { syncPromise } from "./test-utils/test-utils";
-import { createClient } from "../src/matrix";
+import { createClient, IStartClientOpts } from "../src/matrix";
 import { ICreateClientOpts, IDownloadKeyResult, MatrixClient, PendingEventOrdering } from "../src/client";
 import { MockStorageApi } from "./MockStorageApi";
 import { encodeUri } from "../src/utils";
 import { IDeviceKeys, IOneTimeKey } from "../src/crypto/dehydration";
 import { IKeyBackupSession } from "../src/crypto/keybackup";
-import { IHttpOpts } from "../src/http-api";
-import { IKeysUploadResponse, IUploadKeysRequest } from '../src/client';
+import { IKeysUploadResponse, IUploadKeysRequest } from "../src/client";
 
 /**
  * Wrapper for a MockStorageApi, MockHttpBackend and MatrixClient
@@ -39,8 +38,8 @@ import { IKeysUploadResponse, IUploadKeysRequest } from '../src/client';
 export class TestClient {
     public readonly httpBackend: MockHttpBackend;
     public readonly client: MatrixClient;
-    private deviceKeys: IDeviceKeys;
-    private oneTimeKeys: Record<string, IOneTimeKey>;
+    public deviceKeys?: IDeviceKeys | null;
+    public oneTimeKeys?: Record<string, IOneTimeKey>;
 
     constructor(
         public readonly userId?: string,
@@ -50,17 +49,17 @@ export class TestClient {
         options?: Partial<ICreateClientOpts>,
     ) {
         if (sessionStoreBackend === undefined) {
-            sessionStoreBackend = new MockStorageApi();
+            sessionStoreBackend = new MockStorageApi() as unknown as Storage;
         }
 
         this.httpBackend = new MockHttpBackend();
 
         const fullOptions: ICreateClientOpts = {
-            baseUrl: "http://" + userId + ".test.server",
+            baseUrl: "http://" + userId?.slice(1).replace(":", ".") + ".test.server",
             userId: userId,
             accessToken: accessToken,
             deviceId: deviceId,
-            request: this.httpBackend.requestFn as IHttpOpts["request"],
+            fetchFn: this.httpBackend.fetchFn as typeof global.fetch,
             ...options,
         };
         if (!fullOptions.cryptoStore) {
@@ -74,15 +73,18 @@ export class TestClient {
     }
 
     public toString(): string {
-        return 'TestClient[' + this.userId + ']';
+        return "TestClient[" + this.userId + "]";
     }
 
     /**
      * start the client, and wait for it to initialise.
      */
-    public start(): Promise<void> {
-        logger.log(this + ': starting');
-        this.httpBackend.when("GET", "/versions").respond(200, {});
+    public start(opts: IStartClientOpts = {}): Promise<void> {
+        logger.log(this + ": starting");
+        this.httpBackend.when("GET", "/versions").respond(200, {
+            // we have tests that rely on support for lazy-loading members
+            versions: ["r0.5.0"],
+        });
         this.httpBackend.when("GET", "/pushrules").respond(200, {});
         this.httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
         this.expectDeviceKeyUpload();
@@ -94,19 +96,18 @@ export class TestClient {
         this.client.startClient({
             // set this so that we can get hold of failed events
             pendingEventOrdering: PendingEventOrdering.Detached,
+
+            ...opts,
         });
 
-        return Promise.all([
-            this.httpBackend.flushAllExpected(),
-            syncPromise(this.client),
-        ]).then(() => {
-            logger.log(this + ': started');
+        return Promise.all([this.httpBackend.flushAllExpected(), syncPromise(this.client)]).then(() => {
+            logger.log(this + ": started");
         });
     }
 
     /**
      * stop the client
-     * @return {Promise} Resolves once the mock http backend has finished all pending flushes
+     * @returns Promise which resolves once the mock http backend has finished all pending flushes
      */
     public async stop(): Promise<void> {
         this.client.stopClient();
@@ -114,20 +115,30 @@ export class TestClient {
     }
 
     /**
-     * Set up expectations that the client will upload device keys.
+     * Set up expectations that the client will upload device keys (and possibly one-time keys)
      */
     public expectDeviceKeyUpload() {
-        this.httpBackend.when("POST", "/keys/upload")
+        this.httpBackend
+            .when("POST", "/keys/upload")
             .respond<IKeysUploadResponse, IUploadKeysRequest>(200, (_path, content) => {
-                expect(content.one_time_keys).toBe(undefined);
                 expect(content.device_keys).toBeTruthy();
 
-                logger.log(this + ': received device keys');
+                logger.log(this + ": received device keys");
                 // we expect this to happen before any one-time keys are uploaded.
-                expect(Object.keys(this.oneTimeKeys).length).toEqual(0);
+                expect(Object.keys(this.oneTimeKeys!).length).toEqual(0);
 
                 this.deviceKeys = content.device_keys;
-                return { one_time_key_counts: { signed_curve25519: 0 } };
+
+                // the first batch of one-time keys may be uploaded at the same time.
+                if (content.one_time_keys) {
+                    logger.log(`${this}: received ${Object.keys(content.one_time_keys).length} one-time keys`);
+                    this.oneTimeKeys = content.one_time_keys;
+                }
+                return {
+                    one_time_key_counts: {
+                        signed_curve25519: Object.keys(this.oneTimeKeys!).length,
+                    },
+                };
             });
     }
 
@@ -136,40 +147,45 @@ export class TestClient {
      * set up an expectation that the keys will be uploaded, and wait for
      * that to happen.
      *
-     * @returns {Promise} for the one-time keys
+     * @returns Promise for the one-time keys
      */
     public awaitOneTimeKeyUpload(): Promise<Record<string, IOneTimeKey>> {
-        if (Object.keys(this.oneTimeKeys).length != 0) {
+        if (Object.keys(this.oneTimeKeys!).length != 0) {
             // already got one-time keys
-            return Promise.resolve(this.oneTimeKeys);
+            return Promise.resolve(this.oneTimeKeys!);
         }
 
-        this.httpBackend.when("POST", "/keys/upload")
+        this.httpBackend
+            .when("POST", "/keys/upload")
             .respond<IKeysUploadResponse, IUploadKeysRequest>(200, (_path, content: IUploadKeysRequest) => {
                 expect(content.device_keys).toBe(undefined);
                 expect(content.one_time_keys).toBe(undefined);
-                return { one_time_key_counts: {
-                    signed_curve25519: Object.keys(this.oneTimeKeys).length,
-                } };
+                return {
+                    one_time_key_counts: {
+                        signed_curve25519: Object.keys(this.oneTimeKeys!).length,
+                    },
+                };
             });
 
-        this.httpBackend.when("POST", "/keys/upload")
+        this.httpBackend
+            .when("POST", "/keys/upload")
             .respond<IKeysUploadResponse, IUploadKeysRequest>(200, (_path, content: IUploadKeysRequest) => {
                 expect(content.device_keys).toBe(undefined);
                 expect(content.one_time_keys).toBeTruthy();
                 expect(content.one_time_keys).not.toEqual({});
-                logger.log('%s: received %i one-time keys', this,
-                    Object.keys(content.one_time_keys).length);
+                logger.log("%s: received %i one-time keys", this, Object.keys(content.one_time_keys!).length);
                 this.oneTimeKeys = content.one_time_keys;
-                return { one_time_key_counts: {
-                    signed_curve25519: Object.keys(this.oneTimeKeys).length,
-                } };
+                return {
+                    one_time_key_counts: {
+                        signed_curve25519: Object.keys(this.oneTimeKeys!).length,
+                    },
+                };
             });
 
         // this can take ages
-        return this.httpBackend.flush('/keys/upload', 2, 1000).then((flushed) => {
+        return this.httpBackend.flush("/keys/upload", 2, 1000).then((flushed) => {
             expect(flushed).toEqual(2);
-            return this.oneTimeKeys;
+            return this.oneTimeKeys!;
         });
     }
 
@@ -178,46 +194,50 @@ export class TestClient {
      *
      * We check that the query contains each of the users in `response`.
      *
-     * @param {Object} response   response to the query.
+     * @param response -   response to the query.
      */
     public expectKeyQuery(response: IDownloadKeyResult) {
-        this.httpBackend.when('POST', '/keys/query').respond<IDownloadKeyResult>(
-            200, (_path, content) => {
-                Object.keys(response.device_keys).forEach((userId) => {
-                    expect(content.device_keys[userId]).toEqual([]);
-                });
-                return response;
+        this.httpBackend.when("POST", "/keys/query").respond<IDownloadKeyResult>(200, (_path, content) => {
+            Object.keys(response.device_keys).forEach((userId) => {
+                expect((content.device_keys! as Record<string, any>)[userId]).toEqual([]);
             });
+            return response;
+        });
     }
 
     /**
      * Set up expectations that the client will query key backups for a particular session
      */
     public expectKeyBackupQuery(roomId: string, sessionId: string, status: number, response: IKeyBackupSession) {
-        this.httpBackend.when('GET', encodeUri("/room_keys/keys/$roomId/$sessionId", {
-            $roomId: roomId,
-            $sessionId: sessionId,
-        })).respond(status, response);
+        this.httpBackend
+            .when(
+                "GET",
+                encodeUri("/room_keys/keys/$roomId/$sessionId", {
+                    $roomId: roomId,
+                    $sessionId: sessionId,
+                }),
+            )
+            .respond(status, response);
     }
 
     /**
      * get the uploaded curve25519 device key
      *
-     * @return {string} base64 device key
+     * @returns base64 device key
      */
     public getDeviceKey(): string {
-        const keyId = 'curve25519:' + this.deviceId;
-        return this.deviceKeys.keys[keyId];
+        const keyId = "curve25519:" + this.deviceId;
+        return this.deviceKeys!.keys[keyId];
     }
 
     /**
      * get the uploaded ed25519 device key
      *
-     * @return {string} base64 device key
+     * @returns base64 device key
      */
     public getSigningKey(): string {
-        const keyId = 'ed25519:' + this.deviceId;
-        return this.deviceKeys.keys[keyId];
+        const keyId = "ed25519:" + this.deviceId;
+        return this.deviceKeys!.keys[keyId];
     }
 
     /**
@@ -225,10 +245,7 @@ export class TestClient {
      */
     public flushSync(): Promise<void> {
         logger.log(`${this}: flushSync`);
-        return Promise.all([
-            this.httpBackend.flush('/sync', 1),
-            syncPromise(this.client),
-        ]).then(() => {
+        return Promise.all([this.httpBackend.flush("/sync", 1), syncPromise(this.client)]).then(() => {
             logger.log(`${this}: flushSync completed`);
         });
     }
@@ -236,4 +253,8 @@ export class TestClient {
     public isFallbackICEServerAllowed(): boolean {
         return true;
     }
+
+    public getUserId(): string {
+        return this.userId!;
+    }
 }

spec/browserify/setupTests.ts

@@ -0,0 +1,34 @@
+/*
+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 "../../dist/browser-matrix"; // uses browser-matrix instead of the src
+import type { default as BrowserMatrix } from "../../src/browser-index";
+
+// stub for browser-matrix browserify tests
+// @ts-ignore
+global.XMLHttpRequest = jest.fn();
+
+afterAll(() => {
+    // clean up XMLHttpRequest mock
+    // @ts-ignore
+    global.XMLHttpRequest = undefined;
+});
+
+// Akin to spec/setupTests.ts - but that won't affect the browser-matrix bundle
+global.matrixcs = {
+    ...global.matrixcs,
+    timeoutSignal: () => new AbortController().signal,
+} as typeof BrowserMatrix;

spec/browserify/sync-browserify.spec.js

@@ -1,81 +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.
-*/
-
-// load XmlHttpRequest mock
-import "./setupTests";
-import "../../dist/browser-matrix"; // uses browser-matrix instead of the src
-import * as utils from "../test-utils/test-utils";
-import { TestClient } from "../TestClient";
-
-const USER_ID = "@user:test.server";
-const DEVICE_ID = "device_id";
-const ACCESS_TOKEN = "access_token";
-const ROOM_ID = "!room_id:server.test";
-
-describe("Browserify Test", function() {
-    let client;
-    let httpBackend;
-
-    beforeEach(() => {
-        const testClient = new TestClient(USER_ID, DEVICE_ID, ACCESS_TOKEN);
-
-        client = testClient.client;
-        httpBackend = testClient.httpBackend;
-
-        httpBackend.when("GET", "/versions").respond(200, {});
-        httpBackend.when("GET", "/pushrules").respond(200, {});
-        httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
-
-        client.startClient();
-    });
-
-    afterEach(async () => {
-        client.stopClient();
-        httpBackend.stop();
-    });
-
-    it("Sync", function() {
-        const event = utils.mkMembership({
-            room: ROOM_ID,
-            mship: "join",
-            user: "@other_user:server.test",
-            name: "Displayname",
-        });
-
-        const syncData = {
-            next_batch: "batch1",
-            rooms: {
-                join: {},
-            },
-        };
-        syncData.rooms.join[ROOM_ID] = {
-            timeline: {
-                events: [
-                    event,
-                ],
-                limited: false,
-            },
-        };
-
-        httpBackend.when("GET", "/sync").respond(200, syncData);
-        return Promise.race([
-            httpBackend.flushAllExpected(),
-            new Promise((_, reject) => {
-                client.once("sync.unexpectedError", reject);
-            }),
-        ]);
-    }, 20000); // additional timeout as this test can take quite a while
-});

spec/browserify/sync-browserify.spec.ts

@@ -0,0 +1,92 @@
+/*
+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 HttpBackend from "matrix-mock-request";
+
+import "./setupTests"; // uses browser-matrix instead of the src
+import type { MatrixClient } from "../../src";
+
+const USER_ID = "@user:test.server";
+const DEVICE_ID = "device_id";
+const ACCESS_TOKEN = "access_token";
+const ROOM_ID = "!room_id:server.test";
+
+describe("Browserify Test", function () {
+    let client: MatrixClient;
+    let httpBackend: HttpBackend;
+
+    beforeEach(() => {
+        httpBackend = new HttpBackend();
+        client = new global.matrixcs.MatrixClient({
+            baseUrl: "http://test.server",
+            userId: USER_ID,
+            accessToken: ACCESS_TOKEN,
+            deviceId: DEVICE_ID,
+            fetchFn: httpBackend.fetchFn as typeof global.fetch,
+        });
+
+        httpBackend.when("GET", "/versions").respond(200, {});
+        httpBackend.when("GET", "/pushrules").respond(200, {});
+        httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
+    });
+
+    afterEach(async () => {
+        client.stopClient();
+        client.http.abort();
+        httpBackend.verifyNoOutstandingRequests();
+        httpBackend.verifyNoOutstandingExpectation();
+        await httpBackend.stop();
+    });
+
+    it("Sync", async () => {
+        const event = {
+            type: "m.room.member",
+            room_id: ROOM_ID,
+            content: {
+                membership: "join",
+                name: "Displayname",
+            },
+            event_id: "$foobar",
+        };
+
+        const syncData = {
+            next_batch: "batch1",
+            rooms: {
+                join: {
+                    [ROOM_ID]: {
+                        timeline: {
+                            events: [event],
+                            limited: false,
+                        },
+                    },
+                },
+            },
+        };
+
+        httpBackend.when("GET", "/sync").respond(200, syncData);
+        httpBackend.when("GET", "/sync").respond(200, syncData);
+
+        const syncPromise = new Promise((r) => client.once(global.matrixcs.ClientEvent.Sync, r));
+        const unexpectedErrorFn = jest.fn();
+        client.once(global.matrixcs.ClientEvent.SyncUnexpectedError, unexpectedErrorFn);
+
+        client.startClient();
+
+        await httpBackend.flushAllExpected();
+        await syncPromise;
+        expect(unexpectedErrorFn).not.toHaveBeenCalled();
+    }, 20000); // additional timeout as this test can take quite a while
+});

spec/integ/devicelist-integ.spec.js

@@ -1,395 +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';
-
-const ROOM_ID = "!room:id";
-
-/**
- * get a /sync response which contains a single e2e room (ROOM_ID), with the
- * members given
- *
- * @param {string[]} roomMembers
- *
- * @return {object} sync response
- */
-function getSyncResponse(roomMembers) {
-    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: 'join',
-                sender: m,
-            }),
-        ),
-    );
-
-    const syncResponse = {
-        next_batch: 1,
-        rooms: {
-            join: {
-                [ROOM_ID]: {
-                    state: {
-                        events: stateEvents,
-                    },
-                },
-            },
-        },
-    };
-
-    return syncResponse;
-}
-
-describe("DeviceList management:", function() {
-    if (!global.Olm) {
-        logger.warn('not running deviceList tests: Olm not present');
-        return;
-    }
-
-    let sessionStoreBackend;
-    let aliceTestClient;
-
-    async function createTestClient() {
-        const testClient = new TestClient(
-            "@alice:localhost", "xzcvb", "akjgkrgjs", sessionStoreBackend,
-        );
-        await testClient.client.initCrypto();
-        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': {} } });
-        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': {} } });
-        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(() => {
-            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(() => {
-            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(() => {
-            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(() => {
-            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();
-
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
-
-                expect(bobStat).toBeGreaterThan(
-                    0, "Alice should be tracking bob's device list",
-                );
-            });
-        });
-
-        it("when Bob leaves", async function() {
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(
-                200, {
-                    next_batch: 2,
-                    device_lists: {
-                        left: ['@bob:xyz'],
-                    },
-                    rooms: {
-                        join: {
-                            [ROOM_ID]: {
-                                timeline: {
-                                    events: [
-                                        testUtils.mkMembership({
-                                            mship: 'leave',
-                                            sender: '@bob:xyz',
-                                        }),
-                                    ],
-                                },
-                            },
-                        },
-                    },
-                },
-            );
-
-            await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
-
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
-
-                expect(bobStat).toEqual(
-                    0, "Alice should have marked bob's device list as untracked",
-                );
-            });
-        });
-
-        it("when Alice leaves", async function() {
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(
-                200, {
-                    next_batch: 2,
-                    device_lists: {
-                        left: ['@bob:xyz'],
-                    },
-                    rooms: {
-                        leave: {
-                            [ROOM_ID]: {
-                                timeline: {
-                                    events: [
-                                        testUtils.mkMembership({
-                                            mship: 'leave',
-                                            sender: '@bob:xyz',
-                                        }),
-                                    ],
-                                },
-                            },
-                        },
-                    },
-                },
-            );
-
-            await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
-
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
-
-                expect(bobStat).toEqual(
-                    0, "Alice should have marked bob's device list as untracked",
-                );
-            });
-        });
-
-        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();
-
-                anotherTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data.trackingStatus['@bob:xyz'];
-
-                    expect(bobStat).toEqual(
-                        0, "Alice should have marked bob's device list as untracked",
-                    );
-                });
-            } finally {
-                anotherTestClient.stop();
-            }
-        });
-    });
-});

spec/integ/devicelist-integ.spec.ts

@@ -0,0 +1,405 @@
+/*
+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";
+
+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: "join",
+                sender: m,
+            }),
+        ),
+    );
+
+    const syncResponse = {
+        next_batch: 1,
+        rooms: {
+            join: {
+                [ROOM_ID]: {
+                    state: {
+                        events: stateEvents,
+                    },
+                },
+            },
+        },
+    };
+
+    return syncResponse;
+}
+
+describe("DeviceList management:", function () {
+    if (!global.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.initCrypto();
+        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: "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: "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();
+            }
+        });
+    });
+});

spec/integ/matrix-client-crypto.spec.js

@@ -1,758 +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 `megolm.spec.js`.
- */
-
-// load olm before the sdk if possible
-import '../olm-loader';
-
-import { logger } from '../../src/logger';
-import * as testUtils from "../test-utils/test-utils";
-import { TestClient } from "../TestClient";
-import { CRYPTO_ENABLED } from "../../src/client";
-
-let aliTestClient;
-const roomId = "!room:localhost";
-const aliUserId = "@ali:localhost";
-const aliDeviceId = "zxcvb";
-const aliAccessToken = "aseukfgwef";
-let bobTestClient;
-const bobUserId = "@bob:localhost";
-const bobDeviceId = "bvcxz";
-const bobAccessToken = "fewgfkuesa";
-let aliMessages;
-let bobMessages;
-
-function bobUploadsDeviceKeys() {
-    bobTestClient.expectDeviceKeyUpload();
-    return Promise.all([
-        bobTestClient.client.uploadKeys(),
-        bobTestClient.httpBackend.flush(),
-    ]).then(() => {
-        expect(Object.keys(bobTestClient.deviceKeys).length).not.toEqual(0);
-    });
-}
-
-/**
- * Set an expectation that ali will query bobs keys; then flush the http request.
- *
- * @return {promise} resolves once the http request has completed.
- */
-function expectAliQueryKeys() {
-    // can't query keys before bob has uploaded them
-    expect(bobTestClient.deviceKeys).toBeTruthy();
-
-    const bobKeys = {};
-    bobKeys[bobDeviceId] = bobTestClient.deviceKeys;
-    aliTestClient.httpBackend.when("POST", "/keys/query")
-            .respond(200, function(path, content) {
-        expect(content.device_keys[bobUserId]).toEqual(
-            [],
-            "Expected Alice to key query for " + bobUserId + ", got " +
-            Object.keys(content.device_keys),
-        );
-        const result = {};
-        result[bobUserId] = bobKeys;
-        return { device_keys: result };
-    });
-    return aliTestClient.httpBackend.flush("/keys/query", 1);
-}
-
-/**
- * Set an expectation that bob will query alis keys; then flush the http request.
- *
- * @return {promise} which resolves once the http request has completed.
- */
-function expectBobQueryKeys() {
-    // can't query keys before ali has uploaded them
-    expect(aliTestClient.deviceKeys).toBeTruthy();
-
-    const aliKeys = {};
-    aliKeys[aliDeviceId] = aliTestClient.deviceKeys;
-    logger.log("query result will be", aliKeys);
-
-    bobTestClient.httpBackend.when(
-        "POST", "/keys/query",
-    ).respond(200, function(path, content) {
-        expect(content.device_keys[aliUserId]).toEqual(
-            [],
-            "Expected Bob to key query for " + aliUserId + ", got " +
-            Object.keys(content.device_keys),
-        );
-        const result = {};
-        result[aliUserId] = aliKeys;
-        return { device_keys: result };
-    });
-    return bobTestClient.httpBackend.flush("/keys/query", 1);
-}
-
-/**
- * Set an expectation that ali will claim one of bob's keys; then flush the http request.
- *
- * @return {promise} resolves once the http request has completed.
- */
-function expectAliClaimKeys() {
-    return bobTestClient.awaitOneTimeKeyUpload().then((keys) => {
-        aliTestClient.httpBackend.when(
-            "POST", "/keys/claim",
-        ).respond(200, function(path, content) {
-            const claimType = content.one_time_keys[bobUserId][bobDeviceId];
-            expect(claimType).toEqual("signed_curve25519");
-            let keyId = null;
-            for (keyId in keys) {
-                if (bobTestClient.oneTimeKeys.hasOwnProperty(keyId)) {
-                    if (keyId.indexOf(claimType + ":") === 0) {
-                        break;
-                    }
-                }
-            }
-            const result = {};
-            result[bobUserId] = {};
-            result[bobUserId][bobDeviceId] = {};
-            result[bobUserId][bobDeviceId][keyId] = keys[keyId];
-            return { one_time_keys: result };
-        });
-    }).then(() => {
-        // 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.
-        return aliTestClient.httpBackend.flush("/keys/claim", 1, 500).then((r) => {
-            expect(r).toEqual(1, "Ali did not claim Bob's keys");
-        });
-    });
-}
-
-function aliDownloadsKeys() {
-    // can't query keys before bob has uploaded them
-    expect(bobTestClient.getSigningKey()).toBeTruthy();
-
-    const p1 = aliTestClient.client.downloadKeys([bobUserId]).then(function() {
-        return aliTestClient.client.getStoredDevicesForUser(bobUserId);
-    }).then((devices) => {
-        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)
-    return Promise.all([p1, p2]).then(() => {
-        return aliTestClient.client.crypto.deviceList.saveIfDirty();
-    }).then(() => {
-        aliTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-            const devices = data.devices[bobUserId];
-            expect(devices[bobDeviceId].keys).toEqual(bobTestClient.deviceKeys.keys);
-            expect(devices[bobDeviceId].verified).
-                toBe(0); // DeviceVerification.UNVERIFIED
-        });
-    });
-}
-
-function aliEnablesEncryption() {
-    return aliTestClient.client.setRoomEncryption(roomId, {
-        algorithm: "m.olm.v1.curve25519-aes-sha2",
-    }).then(function() {
-        expect(aliTestClient.client.isRoomEncrypted(roomId)).toBeTruthy();
-    });
-}
-
-function bobEnablesEncryption() {
-    return bobTestClient.client.setRoomEncryption(roomId, {
-        algorithm: "m.olm.v1.curve25519-aes-sha2",
-    }).then(function() {
-       expect(bobTestClient.client.isRoomEncrypted(roomId)).toBeTruthy();
-    });
-}
-
-/**
- * Ali sends a message, first claiming e2e keys. Set the expectations and
- * check the results.
- *
- * @return {promise} which resolves to the ciphertext for Bob's device.
- */
-function aliSendsFirstMessage() {
-    return Promise.all([
-        sendMessage(aliTestClient.client),
-        expectAliQueryKeys()
-            .then(expectAliClaimKeys)
-            .then(expectAliSendMessageRequest),
-    ]).then(function([_, ciphertext]) {
-        return ciphertext;
-    });
-}
-
-/**
- * Ali sends a message without first claiming e2e keys. Set the expectations
- * and check the results.
- *
- * @return {promise} which resolves to the ciphertext for Bob's device.
- */
-function aliSendsMessage() {
-    return Promise.all([
-        sendMessage(aliTestClient.client),
-        expectAliSendMessageRequest(),
-    ]).then(function([_, ciphertext]) {
-        return ciphertext;
-    });
-}
-
-/**
- * Bob sends a message, first querying (but not claiming) e2e keys. Set the
- * expectations and check the results.
- *
- * @return {promise} which resolves to the ciphertext for Ali's device.
- */
-function bobSendsReplyMessage() {
-    return Promise.all([
-        sendMessage(bobTestClient.client),
-        expectBobQueryKeys()
-            .then(expectBobSendMessageRequest),
-    ]).then(function([_, ciphertext]) {
-        return ciphertext;
-    });
-}
-
-/**
- * Set an expectation that Ali will send a message, and flush the request
- *
- * @return {promise} which resolves to the ciphertext for Bob's device.
- */
-function expectAliSendMessageRequest() {
-    return expectSendMessageRequest(aliTestClient.httpBackend).then(function(content) {
-        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
- *
- * @return {promise} which resolves to the ciphertext for Bob's device.
- */
-function expectBobSendMessageRequest() {
-    return expectSendMessageRequest(bobTestClient.httpBackend).then(function(content) {
-        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) {
-    return client.sendMessage(
-        roomId, { msgtype: "m.text", body: "Hello, World" },
-    );
-}
-
-function expectSendMessageRequest(httpBackend) {
-    const path = "/send/m.room.encrypted/";
-    const prom = new Promise((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
-    return httpBackend.flush(path, 1).then(() => prom);
-}
-
-function aliRecvMessage() {
-    const message = bobMessages.shift();
-    return recvMessage(
-        aliTestClient.httpBackend, aliTestClient.client, bobUserId, message,
-    );
-}
-
-function bobRecvMessage() {
-    const message = aliMessages.shift();
-    return recvMessage(
-        bobTestClient.httpBackend, bobTestClient.client, aliUserId, message,
-    );
-}
-
-function recvMessage(httpBackend, client, sender, message) {
-    const syncData = {
-        next_batch: "x",
-        rooms: {
-            join: {
-
-            },
-        },
-    };
-    syncData.rooms.join[roomId] = {
-        timeline: {
-            events: [
-                testUtils.mkEvent({
-                    type: "m.room.encrypted",
-                    room: roomId,
-                    content: message,
-                    sender: sender,
-                }),
-            ],
-        },
-    };
-    httpBackend.when("GET", "/sync").respond(200, syncData);
-
-    const eventPromise = new Promise((resolve, reject) => {
-        const onEvent = function(event) {
-            // ignore the m.room.member events
-            if (event.getType() == "m.room.member") {
-                return;
-            }
-            logger.log(client.credentials.userId + " received event",
-                        event);
-
-            client.removeListener("event", onEvent);
-            resolve(event);
-        };
-        client.on("event", onEvent);
-    });
-
-    httpBackend.flush();
-
-    return eventPromise.then((event) => {
-        expect(event.isEncrypted()).toBeTruthy();
-
-        // it may still be being decrypted
-        return testUtils.awaitDecryption(event);
-    }).then((event) => {
-        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).
- *
- * @param {TestClient} testClient
- * @returns {Promise} which resolves when the sync has been flushed.
- */
-function firstSync(testClient) {
-    // send a sync response including our test room.
-    const syncData = {
-        next_batch: "x",
-        rooms: {
-            join: { },
-        },
-    };
-    syncData.rooms.join[roomId] = {
-        state: {
-            events: [
-                testUtils.mkMembership({
-                    mship: "join",
-                    user: aliUserId,
-                }),
-                testUtils.mkMembership({
-                    mship: "join",
-                    user: bobUserId,
-                }),
-            ],
-        },
-        timeline: {
-            events: [],
-        },
-    };
-
-    testClient.httpBackend.when("GET", "/sync").respond(200, syncData);
-    return testClient.flushSync();
-}
-
-describe("MatrixClient crypto", function() {
-    if (!CRYPTO_ENABLED) {
-        return;
-    }
-
-    beforeEach(async function() {
-        aliTestClient = new TestClient(aliUserId, aliDeviceId, aliAccessToken);
-        await aliTestClient.client.initCrypto();
-
-        bobTestClient = new TestClient(bobUserId, bobDeviceId, bobAccessToken);
-        await bobTestClient.client.initCrypto();
-
-        aliMessages = [];
-        bobMessages = [];
-    });
-
-    afterEach(function() {
-        aliTestClient.httpBackend.verifyNoOutstandingExpectation();
-        bobTestClient.httpBackend.verifyNoOutstandingExpectation();
-
-        return Promise.all([aliTestClient.stop(), bobTestClient.stop()]);
-    });
-
-    it("Bob uploads device keys", function() {
-        return Promise.resolve()
-            .then(bobUploadsDeviceKeys);
-    });
-
-    it("Ali downloads Bobs device keys", function() {
-        return Promise.resolve()
-            .then(bobUploadsDeviceKeys)
-            .then(aliDownloadsKeys);
-    });
-
-    it("Ali gets keys with an invalid signature", function() {
-        return Promise.resolve()
-            .then(bobUploadsDeviceKeys)
-            .then(function() {
-                // tamper bob's keys
-                const bobDeviceKeys = bobTestClient.deviceKeys;
-                expect(bobDeviceKeys.keys["curve25519:" + bobDeviceId]).toBeTruthy();
-                bobDeviceKeys.keys["curve25519:" + bobDeviceId] += "abc";
-
-                return Promise.all([
-                    aliTestClient.client.downloadKeys([bobUserId]),
-                    expectAliQueryKeys(),
-                ]);
-            }).then(function() {
-                return aliTestClient.client.getStoredDevicesForUser(bobUserId);
-            }).then((devices) => {
-                // should get an empty list
-                expect(devices).toEqual([]);
-            });
-    });
-
-    it("Ali gets keys with an incorrect userId", function() {
-        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 = {};
-        bobKeys[bobDeviceId] = bobDeviceKeys;
-        aliTestClient.httpBackend.when(
-            "POST", "/keys/query",
-        ).respond(200, function(path, content) {
-            const result = {};
-            result[bobUserId] = bobKeys;
-            return { device_keys: result };
-        });
-
-        return Promise.all([
-            aliTestClient.client.downloadKeys([bobUserId, eveUserId]),
-            aliTestClient.httpBackend.flush("/keys/query", 1),
-        ]).then(function() {
-            return Promise.all([
-                aliTestClient.client.getStoredDevicesForUser(bobUserId),
-                aliTestClient.client.getStoredDevicesForUser(eveUserId),
-            ]);
-        }).then(([bobDevices, eveDevices]) => {
-            // should get an empty list
-            expect(bobDevices).toEqual([]);
-            expect(eveDevices).toEqual([]);
-        });
-    });
-
-    it("Ali gets keys with an incorrect deviceId", function() {
-        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 = {};
-        bobKeys[bobDeviceId] = bobDeviceKeys;
-        aliTestClient.httpBackend.when(
-            "POST", "/keys/query",
-        ).respond(200, function(path, content) {
-            const result = {};
-            result[bobUserId] = bobKeys;
-            return { device_keys: result };
-        });
-
-        return Promise.all([
-            aliTestClient.client.downloadKeys([bobUserId]),
-            aliTestClient.httpBackend.flush("/keys/query", 1),
-        ]).then(function() {
-            return aliTestClient.client.getStoredDevicesForUser(bobUserId);
-        }).then((devices) => {
-            // should get an empty list
-            expect(devices).toEqual([]);
-        });
-    });
-
-    it("Bob starts his client and uploads device keys and one-time keys", function() {
-        return Promise.resolve()
-            .then(() => bobTestClient.start())
-            .then(() => bobTestClient.awaitOneTimeKeyUpload())
-            .then((keys) => {
-                expect(Object.keys(keys).length).toEqual(5);
-                expect(Object.keys(bobTestClient.deviceKeys).length).not.toEqual(0);
-            });
-    });
-
-    it("Ali sends a message", function() {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
-        return Promise.resolve()
-            .then(() => aliTestClient.start())
-            .then(() => bobTestClient.start())
-            .then(() => firstSync(aliTestClient))
-            .then(aliEnablesEncryption)
-            .then(aliSendsFirstMessage);
-    });
-
-    it("Bob receives a message", function() {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
-        return Promise.resolve()
-            .then(() => aliTestClient.start())
-            .then(() => bobTestClient.start())
-            .then(() => firstSync(aliTestClient))
-            .then(aliEnablesEncryption)
-            .then(aliSendsFirstMessage)
-            .then(bobRecvMessage);
-    });
-
-    it("Bob receives a message with a bogus sender", function() {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
-        return Promise.resolve()
-            .then(() => aliTestClient.start())
-            .then(() => bobTestClient.start())
-            .then(() => firstSync(aliTestClient))
-            .then(aliEnablesEncryption)
-            .then(aliSendsFirstMessage)
-            .then(function() {
-                const message = aliMessages.shift();
-                const syncData = {
-                    next_batch: "x",
-                    rooms: {
-                        join: {
-
-                        },
-                    },
-                };
-                syncData.rooms.join[roomId] = {
-                    timeline: {
-                        events: [
-                            testUtils.mkEvent({
-                                type: "m.room.encrypted",
-                                room: roomId,
-                                content: message,
-                                sender: "@bogus:sender",
-                            }),
-                        ],
-                    },
-                };
-                bobTestClient.httpBackend.when("GET", "/sync").respond(200, syncData);
-
-                const eventPromise = new Promise((resolve, reject) => {
-                    const onEvent = function(event) {
-                        logger.log(bobUserId + " received event",
-                                    event);
-                        resolve(event);
-                    };
-                    bobTestClient.client.once("event", onEvent);
-                });
-
-                bobTestClient.httpBackend.flush();
-                return eventPromise;
-            }).then((event) => {
-                expect(event.isEncrypted()).toBeTruthy();
-
-                // it may still be being decrypted
-                return testUtils.awaitDecryption(event);
-            }).then((event) => {
-                expect(event.getType()).toEqual("m.room.message");
-                expect(event.getContent().msgtype).toEqual("m.bad.encrypted");
-            });
-    });
-
-    it("Ali blocks Bob's device", function() {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
-        return Promise.resolve()
-            .then(() => aliTestClient.start())
-            .then(() => bobTestClient.start())
-            .then(() => firstSync(aliTestClient))
-            .then(aliEnablesEncryption)
-            .then(aliDownloadsKeys)
-            .then(function() {
-                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({});
-                      });
-                return Promise.all([p1, p2]);
-            });
-    });
-
-    it("Bob receives two pre-key messages", function() {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
-        return Promise.resolve()
-            .then(() => aliTestClient.start())
-            .then(() => bobTestClient.start())
-            .then(() => firstSync(aliTestClient))
-            .then(aliEnablesEncryption)
-            .then(aliSendsFirstMessage)
-            .then(bobRecvMessage)
-            .then(aliSendsMessage)
-            .then(bobRecvMessage);
-    });
-
-    it("Bob replies to the message", function() {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
-        bobTestClient.expectKeyQuery({ device_keys: { [bobUserId]: {} } });
-        return Promise.resolve()
-            .then(() => aliTestClient.start())
-            .then(() => bobTestClient.start())
-            .then(() => firstSync(aliTestClient))
-            .then(() => firstSync(bobTestClient))
-            .then(aliEnablesEncryption)
-            .then(aliSendsFirstMessage)
-            .then(bobRecvMessage)
-            .then(bobEnablesEncryption)
-            .then(bobSendsReplyMessage).then(function(ciphertext) {
-                expect(ciphertext.type).toEqual(1, "Unexpected cipghertext type.");
-            }).then(aliRecvMessage);
-    });
-
-    it("Ali does a key query when encryption is enabled", function() {
-        // enabling encryption in the room should make alice download devices
-        // for both members.
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
-        return Promise.resolve()
-            .then(() => aliTestClient.start())
-            .then(() => firstSync(aliTestClient))
-            .then(() => {
-                const syncData = {
-                    next_batch: '2',
-                    rooms: {
-                        join: {},
-                    },
-                };
-                syncData.rooms.join[roomId] = {
-                    state: {
-                        events: [
-                            testUtils.mkEvent({
-                                type: 'm.room.encryption',
-                                skey: '',
-                                content: {
-                                    algorithm: 'm.olm.v1.curve25519-aes-sha2',
-                                },
-                            }),
-                        ],
-                    },
-                };
-
-                aliTestClient.httpBackend.when('GET', '/sync').respond(
-                    200, syncData);
-                return aliTestClient.httpBackend.flush('/sync', 1);
-            }).then(() => {
-                aliTestClient.expectKeyQuery({
-                    device_keys: {
-                        [bobUserId]: {},
-                    },
-                });
-                return aliTestClient.httpBackend.flushAllExpected();
-            });
-    });
-
-    it("Upload new oneTimeKeys based on a /sync request - no count-asking", function() {
-        // 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
-
-        return Promise.resolve()
-            .then(() => {
-                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);
-
-                aliTestClient.client.startClient({});
-
-                return httpBackend.flushAllExpected().then(() => {
-                    logger.log(aliTestClient + ': started');
-                });
-            })
-            .then(() => httpBackend.when("POST", "/keys/upload")
-                .respond(200, (path, content) => {
-                    expect(content.one_time_keys).toBeTruthy();
-                    expect(content.one_time_keys).not.toEqual({});
-                    expect(Object.keys(content.one_time_keys).length)
-                        .toBeGreaterThanOrEqual(1);
-                    logger.log('received %i one-time keys',
-                                Object.keys(content.one_time_keys).length);
-                    // cancel futher calls by telling the client
-                    // we have more than we need
-                    return {
-                       one_time_key_counts: {
-                           signed_curve25519: 70,
-                       },
-                    };
-                }))
-            .then(() => httpBackend.flushAllExpected());
-    });
-});

spec/integ/matrix-client-event-emitter.spec.js

@@ -1,331 +0,0 @@
-import * as utils from "../test-utils/test-utils";
-import { TestClient } from "../TestClient";
-
-describe("MatrixClient events", function() {
-    let client;
-    let httpBackend;
-    const selfUserId = "@alice:localhost";
-    const selfAccessToken = "aseukfgwef";
-
-    beforeEach(function() {
-        const testClient = new TestClient(selfUserId, "DEVICE", selfAccessToken);
-        client = testClient.client;
-        httpBackend = testClient.httpBackend;
-        httpBackend.when("GET", "/versions").respond(200, {});
-        httpBackend.when("GET", "/pushrules").respond(200, {});
-        httpBackend.when("POST", "/filter").respond(200, { filter_id: "a filter id" });
-    });
-
-    afterEach(function() {
-        httpBackend.verifyNoOutstandingExpectation();
-        client.stopClient();
-        return httpBackend.stop();
-    });
-
-    describe("emissions", function() {
-        const SYNC_DATA = {
-            next_batch: "s_5_3",
-            presence: {
-                events: [
-                    utils.mkPresence({
-                        user: "@foo:bar", name: "Foo Bar", presence: "online",
-                    }),
-                ],
-            },
-            rooms: {
-                join: {
-                    "!erufh:bar": {
-                        timeline: {
-                            events: [
-                                utils.mkMessage({
-                                    room: "!erufh:bar", user: "@foo:bar", msg: "hmmm",
-                                }),
-                            ],
-                            prev_batch: "s",
-                        },
-                        state: {
-                            events: [
-                                utils.mkMembership({
-                                    room: "!erufh:bar", mship: "join", user: "@foo:bar",
-                                }),
-                                utils.mkEvent({
-                                    type: "m.room.create", room: "!erufh:bar",
-                                    user: "@foo:bar",
-                                    content: {
-                                        creator: "@foo:bar",
-                                    },
-                                }),
-                            ],
-                        },
-                    },
-                },
-            },
-        };
-        const NEXT_SYNC_DATA = {
-            next_batch: "e_6_7",
-            rooms: {
-                join: {
-                    "!erufh:bar": {
-                        timeline: {
-                            events: [
-                                utils.mkMessage({
-                                    room: "!erufh:bar", user: "@foo:bar",
-                                    msg: "ello ello",
-                                }),
-                                utils.mkMessage({
-                                    room: "!erufh:bar", user: "@foo:bar", msg: ":D",
-                                }),
-                            ],
-                        },
-                        ephemeral: {
-                            events: [
-                                utils.mkEvent({
-                                    type: "m.typing", room: "!erufh:bar", content: {
-                                        user_ids: ["@foo:bar"],
-                                    },
-                                }),
-                            ],
-                        },
-                    },
-                },
-            },
-        };
-
-        it("should emit events from both the first and subsequent /sync calls",
-        function() {
-            httpBackend.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-
-            let expectedEvents = [];
-            expectedEvents = expectedEvents.concat(
-                SYNC_DATA.presence.events,
-                SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
-                SYNC_DATA.rooms.join["!erufh:bar"].state.events,
-                NEXT_SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
-                NEXT_SYNC_DATA.rooms.join["!erufh:bar"].ephemeral.events,
-            );
-
-            client.on("event", function(event) {
-                let found = false;
-                for (let i = 0; i < expectedEvents.length; i++) {
-                    if (expectedEvents[i].event_id === event.getId()) {
-                        expectedEvents.splice(i, 1);
-                        found = true;
-                        break;
-                    }
-                }
-                expect(found).toBe(
-                    true, "Unexpected 'event' emitted: " + event.getType(),
-                );
-            });
-
-            client.startClient();
-
-            return Promise.all([
-                // wait for two SYNCING events
-                utils.syncPromise(client).then(() => {
-                    return utils.syncPromise(client);
-                }),
-                httpBackend.flushAllExpected(),
-            ]).then(() => {
-                expect(expectedEvents.length).toEqual(
-                    0, "Failed to see all events from /sync calls",
-                );
-            });
-        });
-
-        it("should emit User events", function(done) {
-            httpBackend.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-            let fired = false;
-            client.on("User.presence", function(event, user) {
-                fired = true;
-                expect(user).toBeTruthy();
-                expect(event).toBeTruthy();
-                if (!user || !event) {
-                    return;
-                }
-
-                expect(event.event).toMatch(SYNC_DATA.presence.events[0]);
-                expect(user.presence).toEqual(
-                    SYNC_DATA.presence.events[0].content.presence,
-                );
-            });
-            client.startClient();
-
-            httpBackend.flushAllExpected().then(function() {
-                expect(fired).toBe(true, "User.presence didn't fire.");
-                done();
-            });
-        });
-
-        it("should emit Room events", function() {
-            httpBackend.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-            let roomInvokeCount = 0;
-            let roomNameInvokeCount = 0;
-            let timelineFireCount = 0;
-            client.on("Room", function(room) {
-                roomInvokeCount++;
-                expect(room.roomId).toEqual("!erufh:bar");
-            });
-            client.on("Room.timeline", function(event, room) {
-                timelineFireCount++;
-                expect(room.roomId).toEqual("!erufh:bar");
-            });
-            client.on("Room.name", function(room) {
-                roomNameInvokeCount++;
-            });
-
-            client.startClient();
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client, 2),
-            ]).then(function() {
-                expect(roomInvokeCount).toEqual(
-                    1, "Room fired wrong number of times.",
-                );
-                expect(roomNameInvokeCount).toEqual(
-                    1, "Room.name fired wrong number of times.",
-                );
-                expect(timelineFireCount).toEqual(
-                    3, "Room.timeline fired the wrong number of times",
-                );
-            });
-        });
-
-        it("should emit RoomState events", function() {
-            httpBackend.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-
-            const roomStateEventTypes = [
-                "m.room.member", "m.room.create",
-            ];
-            let eventsInvokeCount = 0;
-            let membersInvokeCount = 0;
-            let newMemberInvokeCount = 0;
-            client.on("RoomState.events", function(event, state) {
-                eventsInvokeCount++;
-                const index = roomStateEventTypes.indexOf(event.getType());
-                expect(index).not.toEqual(
-                    -1, "Unexpected room state event type: " + event.getType(),
-                );
-                if (index >= 0) {
-                    roomStateEventTypes.splice(index, 1);
-                }
-            });
-            client.on("RoomState.members", function(event, state, member) {
-                membersInvokeCount++;
-                expect(member.roomId).toEqual("!erufh:bar");
-                expect(member.userId).toEqual("@foo:bar");
-                expect(member.membership).toEqual("join");
-            });
-            client.on("RoomState.newMember", function(event, state, member) {
-                newMemberInvokeCount++;
-                expect(member.roomId).toEqual("!erufh:bar");
-                expect(member.userId).toEqual("@foo:bar");
-                expect(member.membership).toBeFalsy();
-            });
-
-            client.startClient();
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client, 2),
-            ]).then(function() {
-                expect(membersInvokeCount).toEqual(
-                    1, "RoomState.members fired wrong number of times",
-                );
-                expect(newMemberInvokeCount).toEqual(
-                    1, "RoomState.newMember fired wrong number of times",
-                );
-                expect(eventsInvokeCount).toEqual(
-                    2, "RoomState.events fired wrong number of times",
-                );
-            });
-        });
-
-        it("should emit RoomMember events", function() {
-            httpBackend.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-
-            let typingInvokeCount = 0;
-            let powerLevelInvokeCount = 0;
-            let nameInvokeCount = 0;
-            let membershipInvokeCount = 0;
-            client.on("RoomMember.name", function(event, member) {
-                nameInvokeCount++;
-            });
-            client.on("RoomMember.typing", function(event, member) {
-                typingInvokeCount++;
-                expect(member.typing).toBe(true);
-            });
-            client.on("RoomMember.powerLevel", function(event, member) {
-                powerLevelInvokeCount++;
-            });
-            client.on("RoomMember.membership", function(event, member) {
-                membershipInvokeCount++;
-                expect(member.membership).toEqual("join");
-            });
-
-            client.startClient();
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client, 2),
-            ]).then(function() {
-                expect(typingInvokeCount).toEqual(
-                    1, "RoomMember.typing fired wrong number of times",
-                );
-                expect(powerLevelInvokeCount).toEqual(
-                    0, "RoomMember.powerLevel fired wrong number of times",
-                );
-                expect(nameInvokeCount).toEqual(
-                    0, "RoomMember.name fired wrong number of times",
-                );
-                expect(membershipInvokeCount).toEqual(
-                    1, "RoomMember.membership fired wrong number of times",
-                );
-            });
-        });
-
-        it("should emit Session.logged_out on M_UNKNOWN_TOKEN", function() {
-            const error = { errcode: 'M_UNKNOWN_TOKEN' };
-            httpBackend.when("GET", "/sync").respond(401, error);
-
-            let sessionLoggedOutCount = 0;
-            client.on("Session.logged_out", function(errObj) {
-                sessionLoggedOutCount++;
-                expect(errObj.data).toEqual(error);
-            });
-
-            client.startClient();
-
-            return httpBackend.flushAllExpected().then(function() {
-                expect(sessionLoggedOutCount).toEqual(
-                    1, "Session.logged_out fired wrong number of times",
-                );
-            });
-        });
-
-        it("should emit Session.logged_out on M_UNKNOWN_TOKEN (soft logout)", function() {
-            const error = { errcode: 'M_UNKNOWN_TOKEN', soft_logout: true };
-            httpBackend.when("GET", "/sync").respond(401, error);
-
-            let sessionLoggedOutCount = 0;
-            client.on("Session.logged_out", function(errObj) {
-                sessionLoggedOutCount++;
-                expect(errObj.data).toEqual(error);
-            });
-
-            client.startClient();
-
-            return httpBackend.flushAllExpected().then(function() {
-                expect(sessionLoggedOutCount).toEqual(
-                    1, "Session.logged_out fired wrong number of times",
-                );
-            });
-        });
-    });
-});

spec/integ/matrix-client-event-emitter.spec.ts

@@ -0,0 +1,333 @@
+/*
+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 HttpBackend from "matrix-mock-request";
+
+import {
+    ClientEvent,
+    HttpApiEvent,
+    IEvent,
+    MatrixClient,
+    RoomEvent,
+    RoomMemberEvent,
+    RoomStateEvent,
+    UserEvent,
+} from "../../src";
+import * as utils from "../test-utils/test-utils";
+import { TestClient } from "../TestClient";
+
+describe("MatrixClient events", function () {
+    const selfUserId = "@alice:localhost";
+    const selfAccessToken = "aseukfgwef";
+    let client: MatrixClient | undefined;
+    let httpBackend: HttpBackend | undefined;
+
+    const setupTests = (): [MatrixClient, HttpBackend] => {
+        const testClient = new TestClient(selfUserId, "DEVICE", selfAccessToken);
+        const client = testClient.client;
+        const httpBackend = testClient.httpBackend;
+        httpBackend!.when("GET", "/versions").respond(200, {});
+        httpBackend!.when("GET", "/pushrules").respond(200, {});
+        httpBackend!.when("POST", "/filter").respond(200, { filter_id: "a filter id" });
+
+        return [client!, httpBackend];
+    };
+
+    beforeEach(function () {
+        [client!, httpBackend] = setupTests();
+    });
+
+    afterEach(function () {
+        httpBackend?.verifyNoOutstandingExpectation();
+        client?.stopClient();
+        return httpBackend?.stop();
+    });
+
+    describe("emissions", function () {
+        const SYNC_DATA = {
+            next_batch: "s_5_3",
+            presence: {
+                events: [
+                    utils.mkPresence({
+                        user: "@foo:bar",
+                        name: "Foo Bar",
+                        presence: "online",
+                    }),
+                ],
+            },
+            rooms: {
+                join: {
+                    "!erufh:bar": {
+                        timeline: {
+                            events: [
+                                utils.mkMessage({
+                                    room: "!erufh:bar",
+                                    user: "@foo:bar",
+                                    msg: "hmmm",
+                                }),
+                            ],
+                            prev_batch: "s",
+                        },
+                        state: {
+                            events: [
+                                utils.mkMembership({
+                                    room: "!erufh:bar",
+                                    mship: "join",
+                                    user: "@foo:bar",
+                                }),
+                                utils.mkEvent({
+                                    type: "m.room.create",
+                                    room: "!erufh:bar",
+                                    user: "@foo:bar",
+                                    content: {
+                                        creator: "@foo:bar",
+                                    },
+                                }),
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+        const NEXT_SYNC_DATA = {
+            next_batch: "e_6_7",
+            rooms: {
+                join: {
+                    "!erufh:bar": {
+                        timeline: {
+                            events: [
+                                utils.mkMessage({
+                                    room: "!erufh:bar",
+                                    user: "@foo:bar",
+                                    msg: "ello ello",
+                                }),
+                                utils.mkMessage({
+                                    room: "!erufh:bar",
+                                    user: "@foo:bar",
+                                    msg: ":D",
+                                }),
+                            ],
+                        },
+                        ephemeral: {
+                            events: [
+                                utils.mkEvent({
+                                    type: "m.typing",
+                                    room: "!erufh:bar",
+                                    content: {
+                                        user_ids: ["@foo:bar"],
+                                    },
+                                }),
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+
+        it("should emit events from both the first and subsequent /sync calls", function () {
+            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
+            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+
+            let expectedEvents: Partial<IEvent>[] = [];
+            expectedEvents = expectedEvents.concat(
+                SYNC_DATA.presence.events,
+                SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
+                SYNC_DATA.rooms.join["!erufh:bar"].state.events,
+                NEXT_SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
+                NEXT_SYNC_DATA.rooms.join["!erufh:bar"].ephemeral.events,
+            );
+
+            client!.on(ClientEvent.Event, function (event) {
+                let found = false;
+                for (let i = 0; i < expectedEvents.length; i++) {
+                    if (expectedEvents[i].event_id === event.getId()) {
+                        expectedEvents.splice(i, 1);
+                        found = true;
+                        break;
+                    }
+                }
+                expect(found).toBe(true);
+            });
+
+            client!.startClient();
+
+            return Promise.all([
+                // wait for two SYNCING events
+                utils.syncPromise(client!).then(() => {
+                    return utils.syncPromise(client!);
+                }),
+                httpBackend!.flushAllExpected(),
+            ]).then(() => {
+                expect(expectedEvents.length).toEqual(0);
+            });
+        });
+
+        it("should emit User events", function (done) {
+            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
+            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+            let fired = false;
+            client!.on(UserEvent.Presence, function (event, user) {
+                fired = true;
+                expect(user).toBeTruthy();
+                expect(event).toBeTruthy();
+                if (!user || !event) {
+                    return;
+                }
+
+                expect(event.event).toEqual(SYNC_DATA.presence.events[0]);
+                expect(user.presence).toEqual(SYNC_DATA.presence.events[0]?.content?.presence);
+            });
+            client!.startClient();
+
+            httpBackend!.flushAllExpected().then(function () {
+                expect(fired).toBe(true);
+                done();
+            });
+        });
+
+        it("should emit Room events", function () {
+            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
+            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+            let roomInvokeCount = 0;
+            let roomNameInvokeCount = 0;
+            let timelineFireCount = 0;
+            client!.on(ClientEvent.Room, function (room) {
+                roomInvokeCount++;
+                expect(room.roomId).toEqual("!erufh:bar");
+            });
+            client!.on(RoomEvent.Timeline, function (event, room) {
+                timelineFireCount++;
+                expect(room?.roomId).toEqual("!erufh:bar");
+            });
+            client!.on(RoomEvent.Name, function (room) {
+                roomNameInvokeCount++;
+            });
+
+            client!.startClient();
+
+            return Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 2)]).then(function () {
+                expect(roomInvokeCount).toEqual(1);
+                expect(roomNameInvokeCount).toEqual(1);
+                expect(timelineFireCount).toEqual(3);
+            });
+        });
+
+        it("should emit RoomState events", function () {
+            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
+            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+
+            const roomStateEventTypes = ["m.room.member", "m.room.create"];
+            let eventsInvokeCount = 0;
+            let membersInvokeCount = 0;
+            let newMemberInvokeCount = 0;
+            client!.on(RoomStateEvent.Events, function (event, state) {
+                eventsInvokeCount++;
+                const index = roomStateEventTypes.indexOf(event.getType());
+                expect(index).not.toEqual(-1);
+                if (index >= 0) {
+                    roomStateEventTypes.splice(index, 1);
+                }
+            });
+            client!.on(RoomStateEvent.Members, function (event, state, member) {
+                membersInvokeCount++;
+                expect(member.roomId).toEqual("!erufh:bar");
+                expect(member.userId).toEqual("@foo:bar");
+                expect(member.membership).toEqual("join");
+            });
+            client!.on(RoomStateEvent.NewMember, function (event, state, member) {
+                newMemberInvokeCount++;
+                expect(member.roomId).toEqual("!erufh:bar");
+                expect(member.userId).toEqual("@foo:bar");
+                expect(member.membership).toBeFalsy();
+            });
+
+            client!.startClient();
+
+            return Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 2)]).then(function () {
+                expect(membersInvokeCount).toEqual(1);
+                expect(newMemberInvokeCount).toEqual(1);
+                expect(eventsInvokeCount).toEqual(2);
+            });
+        });
+
+        it("should emit RoomMember events", function () {
+            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
+            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+
+            let typingInvokeCount = 0;
+            let powerLevelInvokeCount = 0;
+            let nameInvokeCount = 0;
+            let membershipInvokeCount = 0;
+            client!.on(RoomMemberEvent.Name, function (event, member) {
+                nameInvokeCount++;
+            });
+            client!.on(RoomMemberEvent.Typing, function (event, member) {
+                typingInvokeCount++;
+                expect(member.typing).toBe(true);
+            });
+            client!.on(RoomMemberEvent.PowerLevel, function (event, member) {
+                powerLevelInvokeCount++;
+            });
+            client!.on(RoomMemberEvent.Membership, function (event, member) {
+                membershipInvokeCount++;
+                expect(member.membership).toEqual("join");
+            });
+
+            client!.startClient();
+
+            return Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 2)]).then(function () {
+                expect(typingInvokeCount).toEqual(1);
+                expect(powerLevelInvokeCount).toEqual(0);
+                expect(nameInvokeCount).toEqual(0);
+                expect(membershipInvokeCount).toEqual(1);
+            });
+        });
+
+        it("should emit Session.logged_out on M_UNKNOWN_TOKEN", function () {
+            const error = { errcode: "M_UNKNOWN_TOKEN" };
+            httpBackend!.when("GET", "/sync").respond(401, error);
+
+            let sessionLoggedOutCount = 0;
+            client!.on(HttpApiEvent.SessionLoggedOut, function (errObj) {
+                sessionLoggedOutCount++;
+                expect(errObj.data).toEqual(error);
+            });
+
+            client!.startClient();
+
+            return httpBackend!.flushAllExpected().then(function () {
+                expect(sessionLoggedOutCount).toEqual(1);
+            });
+        });
+
+        it("should emit Session.logged_out on M_UNKNOWN_TOKEN (soft logout)", function () {
+            const error = { errcode: "M_UNKNOWN_TOKEN", soft_logout: true };
+            httpBackend!.when("GET", "/sync").respond(401, error);
+
+            let sessionLoggedOutCount = 0;
+            client!.on(HttpApiEvent.SessionLoggedOut, function (errObj) {
+                sessionLoggedOutCount++;
+                expect(errObj.data).toEqual(error);
+            });
+
+            client!.startClient();
+
+            return httpBackend!.flushAllExpected().then(function () {
+                expect(sessionLoggedOutCount).toEqual(1);
+            });
+        });
+    });
+});

spec/integ/matrix-client-opts.spec.ts

@@ -1,14 +1,15 @@
 import HttpBackend from "matrix-mock-request";
 
 import * as utils from "../test-utils/test-utils";
-import { MatrixClient } from "../../src/matrix";
+import { ClientEvent, MatrixClient } from "../../src/matrix";
 import { MatrixScheduler } from "../../src/scheduler";
 import { MemoryStore } from "../../src/store/memory";
 import { MatrixError } from "../../src/http-api";
+import { IStore } from "../../src/store";
 
-describe("MatrixClient opts", function() {
+describe("MatrixClient opts", function () {
     const baseUrl = "http://localhost.or.something";
-    let httpBackend = null;
+    let httpBackend = new HttpBackend();
     const userId = "@alice:localhost";
     const userB = "@bob:localhost";
     const accessToken = "aseukfgwef";
@@ -18,11 +19,14 @@ describe("MatrixClient opts", function() {
         presence: {},
         rooms: {
             join: {
-                "!foo:bar": { // roomId
+                "!foo:bar": {
+                    // roomId
                     timeline: {
                         events: [
                             utils.mkMessage({
-                                room: roomId, user: userB, msg: "hello",
+                                room: roomId,
+                                user: userB,
+                                msg: "hello",
                             }),
                         ],
                         prev_batch: "f_1_1",
@@ -30,19 +34,29 @@ describe("MatrixClient opts", function() {
                     state: {
                         events: [
                             utils.mkEvent({
-                                type: "m.room.name", room: roomId, user: userB,
+                                type: "m.room.name",
+                                room: roomId,
+                                user: userB,
                                 content: {
                                     name: "Old room name",
                                 },
                             }),
                             utils.mkMembership({
-                                room: roomId, mship: "join", user: userB, name: "Bob",
+                                room: roomId,
+                                mship: "join",
+                                user: userB,
+                                name: "Bob",
                             }),
                             utils.mkMembership({
-                                room: roomId, mship: "join", user: userId, name: "Alice",
+                                room: roomId,
+                                mship: "join",
+                                user: userId,
+                                name: "Alice",
                             }),
                             utils.mkEvent({
-                                type: "m.room.create", room: roomId, user: userId,
+                                type: "m.room.create",
+                                room: roomId,
+                                user: userId,
                                 content: {
                                     creator: userId,
                                 },
@@ -54,20 +68,20 @@ describe("MatrixClient opts", function() {
         },
     };
 
-    beforeEach(function() {
+    beforeEach(function () {
         httpBackend = new HttpBackend();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         httpBackend.verifyNoOutstandingExpectation();
         return httpBackend.stop();
     });
 
-    describe("without opts.store", function() {
-        let client;
-        beforeEach(function() {
+    describe("without opts.store", function () {
+        let client: MatrixClient;
+        beforeEach(function () {
             client = new MatrixClient({
-                request: httpBackend.requestFn,
+                fetchFn: httpBackend.fetchFn as typeof global.fetch,
                 store: undefined,
                 baseUrl: baseUrl,
                 userId: userId,
@@ -76,34 +90,34 @@ describe("MatrixClient opts", function() {
             });
         });
 
-        afterEach(function() {
+        afterEach(function () {
             client.stopClient();
         });
 
-        it("should be able to send messages", function(done) {
+        it("should be able to send messages", function (done) {
             const eventId = "$flibble:wibble";
             httpBackend.when("PUT", "/txn1").respond(200, {
                 event_id: eventId,
             });
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
+            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function (res) {
                 expect(res.event_id).toEqual(eventId);
                 done();
             });
             httpBackend.flush("/txn1", 1);
         });
 
-        it("should be able to sync / get new events", async function() {
-            const expectedEventTypes = [ // from /initialSync
-                "m.room.message", "m.room.name", "m.room.member", "m.room.member",
+        it("should be able to sync / get new events", async function () {
+            const expectedEventTypes = [
+                // from /initialSync
+                "m.room.message",
+                "m.room.name",
+                "m.room.member",
+                "m.room.member",
                 "m.room.create",
             ];
-            client.on("event", function(event) {
-                expect(expectedEventTypes.indexOf(event.getType())).not.toEqual(
-                    -1, "Recv unexpected event type: " + event.getType(),
-                );
-                expectedEventTypes.splice(
-                    expectedEventTypes.indexOf(event.getType()), 1,
-                );
+            client.on(ClientEvent.Event, function (event) {
+                expect(expectedEventTypes.indexOf(event.getType())).not.toEqual(-1);
+                expectedEventTypes.splice(expectedEventTypes.indexOf(event.getType()), 1);
             });
             httpBackend.when("GET", "/versions").respond(200, {});
             httpBackend.when("GET", "/pushrules").respond(200, {});
@@ -113,22 +127,17 @@ describe("MatrixClient opts", function() {
             await httpBackend.flush("/versions", 1);
             await httpBackend.flush("/pushrules", 1);
             await httpBackend.flush("/filter", 1);
-            await Promise.all([
-                httpBackend.flush("/sync", 1),
-                utils.syncPromise(client),
-            ]);
-            expect(expectedEventTypes.length).toEqual(
-                0, "Expected to see event types: " + expectedEventTypes,
-            );
+            await Promise.all([httpBackend.flush("/sync", 1), utils.syncPromise(client)]);
+            expect(expectedEventTypes.length).toEqual(0);
         });
     });
 
-    describe("without opts.scheduler", function() {
-        let client;
-        beforeEach(function() {
+    describe("without opts.scheduler", function () {
+        let client: MatrixClient;
+        beforeEach(function () {
             client = new MatrixClient({
-                request: httpBackend.requestFn,
-                store: new MemoryStore(),
+                fetchFn: httpBackend.fetchFn as typeof global.fetch,
+                store: new MemoryStore() as IStore,
                 baseUrl: baseUrl,
                 userId: userId,
                 accessToken: accessToken,
@@ -136,25 +145,31 @@ describe("MatrixClient opts", function() {
             });
         });
 
-        afterEach(function() {
+        afterEach(function () {
             client.stopClient();
         });
 
-        it("shouldn't retry sending events", function(done) {
-            httpBackend.when("PUT", "/txn1").fail(500, new MatrixError({
-                errcode: "M_SOMETHING",
-                error: "Ruh roh",
-            }));
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
-                expect(false).toBe(true, "sendTextMessage resolved but shouldn't");
-            }, function(err) {
-                expect(err.errcode).toEqual("M_SOMETHING");
-                done();
-            });
+        it("shouldn't retry sending events", function (done) {
+            httpBackend.when("PUT", "/txn1").respond(
+                500,
+                new MatrixError({
+                    errcode: "M_SOMETHING",
+                    error: "Ruh roh",
+                }),
+            );
+            client.sendTextMessage("!foo:bar", "a body", "txn1").then(
+                function (res) {
+                    expect(false).toBe(true);
+                },
+                function (err) {
+                    expect(err.errcode).toEqual("M_SOMETHING");
+                    done();
+                },
+            );
             httpBackend.flush("/txn1", 1);
         });
 
-        it("shouldn't queue events", function(done) {
+        it("shouldn't queue events", function (done) {
             httpBackend.when("PUT", "/txn1").respond(200, {
                 event_id: "AAA",
             });
@@ -163,26 +178,26 @@ describe("MatrixClient opts", function() {
             });
             let sentA = false;
             let sentB = false;
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
+            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function (res) {
                 sentA = true;
                 expect(sentB).toBe(true);
             });
-            client.sendTextMessage("!foo:bar", "b body", "txn2").then(function(res) {
+            client.sendTextMessage("!foo:bar", "b body", "txn2").then(function (res) {
                 sentB = true;
                 expect(sentA).toBe(false);
             });
-            httpBackend.flush("/txn2", 1).then(function() {
-                httpBackend.flush("/txn1", 1).then(function() {
+            httpBackend.flush("/txn2", 1).then(function () {
+                httpBackend.flush("/txn1", 1).then(function () {
                     done();
                 });
             });
         });
 
-        it("should be able to send messages", function(done) {
+        it("should be able to send messages", function (done) {
             httpBackend.when("PUT", "/txn1").respond(200, {
                 event_id: "foo",
             });
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
+            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function (res) {
                 expect(res.event_id).toEqual("foo");
                 done();
             });

spec/integ/matrix-client-relations.spec.ts

@@ -0,0 +1,116 @@
+/*
+Copyright 2022 Dominik Henneke
+Copyright 2022 Nordeck IT + Consulting GmbH.
+
+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 HttpBackend from "matrix-mock-request";
+
+import { Direction, MatrixClient, MatrixScheduler } from "../../src/matrix";
+import { TestClient } from "../TestClient";
+
+describe("MatrixClient relations", () => {
+    const userId = "@alice:localhost";
+    const accessToken = "aseukfgwef";
+    const roomId = "!room:here";
+    let client: MatrixClient | undefined;
+    let httpBackend: HttpBackend | undefined;
+
+    const setupTests = (): [MatrixClient, HttpBackend] => {
+        const scheduler = new MatrixScheduler();
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { scheduler });
+        const httpBackend = testClient.httpBackend;
+        const client = testClient.client;
+
+        return [client, httpBackend];
+    };
+
+    beforeEach(() => {
+        [client, httpBackend] = setupTests();
+    });
+
+    afterEach(() => {
+        httpBackend!.verifyNoOutstandingExpectation();
+        return httpBackend!.stop();
+    });
+
+    it("should read related events with the default options", async () => {
+        const response = client!.relations(roomId, "$event-0", null, null);
+
+        httpBackend!.when("GET", "/rooms/!room%3Ahere/event/%24event-0").respond(200, null);
+        httpBackend!
+            .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0?dir=b")
+            .respond(200, { chunk: [], next_batch: "NEXT" });
+
+        await httpBackend!.flushAllExpected();
+
+        expect(await response).toEqual({ events: [], nextBatch: "NEXT", originalEvent: null, prevBatch: null });
+    });
+
+    it("should read related events with relation type", async () => {
+        const response = client!.relations(roomId, "$event-0", "m.reference", null);
+
+        httpBackend!.when("GET", "/rooms/!room%3Ahere/event/%24event-0").respond(200, null);
+        httpBackend!
+            .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0/m.reference?dir=b")
+            .respond(200, { chunk: [], next_batch: "NEXT" });
+
+        await httpBackend!.flushAllExpected();
+
+        expect(await response).toEqual({ events: [], nextBatch: "NEXT", originalEvent: null, prevBatch: null });
+    });
+
+    it("should read related events with relation type and event type", async () => {
+        const response = client!.relations(roomId, "$event-0", "m.reference", "m.room.message");
+
+        httpBackend!.when("GET", "/rooms/!room%3Ahere/event/%24event-0").respond(200, null);
+        httpBackend!
+            .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0/m.reference/m.room.message?dir=b")
+            .respond(200, { chunk: [], next_batch: "NEXT" });
+
+        await httpBackend!.flushAllExpected();
+
+        expect(await response).toEqual({ events: [], nextBatch: "NEXT", originalEvent: null, prevBatch: null });
+    });
+
+    it("should read related events with custom options", async () => {
+        const response = client!.relations(roomId, "$event-0", null, null, {
+            dir: Direction.Forward,
+            from: "FROM",
+            limit: 10,
+            to: "TO",
+        });
+
+        httpBackend!.when("GET", "/rooms/!room%3Ahere/event/%24event-0").respond(200, null);
+        httpBackend!
+            .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0?dir=f&from=FROM&limit=10&to=TO")
+            .respond(200, { chunk: [], next_batch: "NEXT" });
+
+        await httpBackend!.flushAllExpected();
+
+        expect(await response).toEqual({ events: [], nextBatch: "NEXT", originalEvent: null, prevBatch: null });
+    });
+
+    it("should use default direction in the fetchRelations endpoint", async () => {
+        const response = client!.fetchRelations(roomId, "$event-0", null, null);
+
+        httpBackend!
+            .when("GET", "/rooms/!room%3Ahere/relations/%24event-0?dir=b")
+            .respond(200, { chunk: [], next_batch: "NEXT" });
+
+        await httpBackend!.flushAllExpected();
+
+        expect(await response).toEqual({ chunk: [], next_batch: "NEXT" });
+    });
+});

spec/integ/matrix-client-retrying.spec.ts

@@ -14,78 +14,75 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { EventStatus, RoomEvent, MatrixClient } from "../../src/matrix";
-import { MatrixScheduler } from "../../src/scheduler";
+import HttpBackend from "matrix-mock-request";
+
+import { EventStatus, RoomEvent, MatrixClient, MatrixScheduler } from "../../src/matrix";
 import { Room } from "../../src/models/room";
 import { TestClient } from "../TestClient";
 
-describe("MatrixClient retrying", function() {
-    let client: MatrixClient = null;
-    let httpBackend: TestClient["httpBackend"] = null;
-    let scheduler;
+describe("MatrixClient retrying", function () {
     const userId = "@alice:localhost";
     const accessToken = "aseukfgwef";
     const roomId = "!room:here";
-    let room: Room;
+    let client: MatrixClient | undefined;
+    let httpBackend: HttpBackend | undefined;
+    let room: Room | undefined;
 
-    beforeEach(function() {
-        scheduler = new MatrixScheduler();
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { scheduler },
-        );
-        httpBackend = testClient.httpBackend;
-        client = testClient.client;
-        room = new Room(roomId, client, userId);
-        client.store.storeRoom(room);
+    const setupTests = (): [MatrixClient, HttpBackend, Room] => {
+        const scheduler = new MatrixScheduler();
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { scheduler });
+        const httpBackend = testClient.httpBackend;
+        const client = testClient.client;
+        const room = new Room(roomId, client, userId);
+        client!.store.storeRoom(room);
+
+        return [client, httpBackend, room];
+    };
+
+    beforeEach(function () {
+        [client, httpBackend, room] = setupTests();
     });
 
-    afterEach(function() {
-        httpBackend.verifyNoOutstandingExpectation();
-        return httpBackend.stop();
+    afterEach(function () {
+        httpBackend!.verifyNoOutstandingExpectation();
+        return httpBackend!.stop();
     });
 
-    xit("should retry according to MatrixScheduler.retryFn", function() {
+    xit("should retry according to MatrixScheduler.retryFn", function () {});
 
-    });
+    xit("should queue according to MatrixScheduler.queueFn", function () {});
 
-    xit("should queue according to MatrixScheduler.queueFn", function() {
+    xit("should mark events as EventStatus.NOT_SENT when giving up", function () {});
 
-    });
+    xit("should mark events as EventStatus.QUEUED when queued", function () {});
 
-    xit("should mark events as EventStatus.NOT_SENT when giving up", function() {
-
-    });
-
-    xit("should mark events as EventStatus.QUEUED when queued", function() {
-
-    });
-
-    it("should mark events as EventStatus.CANCELLED when cancelled", function() {
+    it("should mark events as EventStatus.CANCELLED when cancelled", function () {
         // send a couple of events; the second will be queued
-        const p1 = client.sendMessage(roomId, {
-            "msgtype": "m.text",
-            "body": "m1",
-        }).then(function() {
-            // we expect the first message to fail
-            throw new Error('Message 1 unexpectedly sent successfully');
-        }, () => {
-            // this is expected
-        });
+        const p1 = client!
+            .sendMessage(roomId, {
+                msgtype: "m.text",
+                body: "m1",
+            })
+            .then(
+                function () {
+                    // we expect the first message to fail
+                    throw new Error("Message 1 unexpectedly sent successfully");
+                },
+                () => {
+                    // this is expected
+                },
+            );
 
         // XXX: it turns out that the promise returned by this message
         // never gets resolved.
         // https://github.com/matrix-org/matrix-js-sdk/issues/496
-        client.sendMessage(roomId, {
-            "msgtype": "m.text",
-            "body": "m2",
+        client!.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "m2",
         });
 
         // both events should be in the timeline at this point
-        const tl = room.getLiveTimeline().getEvents();
+        const tl = room!.getLiveTimeline().getEvents();
         expect(tl.length).toEqual(2);
         const ev1 = tl[0];
         const ev2 = tl[1];
@@ -94,51 +91,46 @@ describe("MatrixClient retrying", function() {
         expect(ev2.status).toEqual(EventStatus.SENDING);
 
         // the first message should get sent, and the second should get queued
-        httpBackend.when("PUT", "/send/m.room.message/").check(function() {
-            // ev2 should now have been queued
-            expect(ev2.status).toEqual(EventStatus.QUEUED);
+        httpBackend!
+            .when("PUT", "/send/m.room.message/")
+            .check(function () {
+                // ev2 should now have been queued
+                expect(ev2.status).toEqual(EventStatus.QUEUED);
 
-            // now we can cancel the second and check everything looks sane
-            client.cancelPendingEvent(ev2);
-            expect(ev2.status).toEqual(EventStatus.CANCELLED);
-            expect(tl.length).toEqual(1);
+                // now we can cancel the second and check everything looks sane
+                client!.cancelPendingEvent(ev2);
+                expect(ev2.status).toEqual(EventStatus.CANCELLED);
+                expect(tl.length).toEqual(1);
 
-            // shouldn't be able to cancel the first message yet
-            expect(function() {
-                client.cancelPendingEvent(ev1);
-            }).toThrow();
-        }).respond(400); // fail the first message
+                // shouldn't be able to cancel the first message yet
+                expect(function () {
+                    client!.cancelPendingEvent(ev1);
+                }).toThrow();
+            })
+            .respond(400); // fail the first message
 
         // wait for the localecho of ev1 to be updated
         const p3 = new Promise<void>((resolve, reject) => {
-            room.on(RoomEvent.LocalEchoUpdated, (ev0) => {
+            room!.on(RoomEvent.LocalEchoUpdated, (ev0) => {
                 if (ev0 === ev1) {
                     resolve();
                 }
             });
-        }).then(function() {
+        }).then(function () {
             expect(ev1.status).toEqual(EventStatus.NOT_SENT);
             expect(tl.length).toEqual(1);
 
             // cancel the first message
-            client.cancelPendingEvent(ev1);
+            client!.cancelPendingEvent(ev1);
             expect(ev1.status).toEqual(EventStatus.CANCELLED);
             expect(tl.length).toEqual(0);
         });
 
-        return Promise.all([
-            p1,
-            p3,
-            httpBackend.flushAllExpected(),
-        ]);
+        return Promise.all([p1, p3, httpBackend!.flushAllExpected()]);
     });
 
-    describe("resending", function() {
-        xit("should be able to resend a NOT_SENT event", function() {
-
-        });
-        xit("should be able to resend a sent event", function() {
-
-        });
+    describe("resending", function () {
+        xit("should be able to resend a NOT_SENT event", function () {});
+        xit("should be able to resend a sent event", function () {});
     });
 });

spec/integ/matrix-client-room-timeline.spec.js

@@ -1,879 +0,0 @@
-import * as utils from "../test-utils/test-utils";
-import { EventStatus } from "../../src/models/event";
-import { RoomEvent } from "../../src";
-import { TestClient } from "../TestClient";
-
-describe("MatrixClient room timelines", function() {
-    let client = null;
-    let httpBackend = null;
-    const userId = "@alice:localhost";
-    const userName = "Alice";
-    const accessToken = "aseukfgwef";
-    const roomId = "!foo:bar";
-    const otherUserId = "@bob:localhost";
-    const USER_MEMBERSHIP_EVENT = utils.mkMembership({
-        room: roomId, mship: "join", user: userId, name: userName,
-    });
-    const ROOM_NAME_EVENT = utils.mkEvent({
-        type: "m.room.name", room: roomId, user: otherUserId,
-        content: {
-            name: "Old room name",
-        },
-    });
-    let NEXT_SYNC_DATA;
-    const SYNC_DATA = {
-        next_batch: "s_5_3",
-        rooms: {
-            join: {
-                "!foo:bar": { // roomId
-                    timeline: {
-                        events: [
-                            utils.mkMessage({
-                                room: roomId, user: otherUserId, msg: "hello",
-                            }),
-                        ],
-                        prev_batch: "f_1_1",
-                    },
-                    state: {
-                        events: [
-                            ROOM_NAME_EVENT,
-                            utils.mkMembership({
-                                room: roomId, mship: "join",
-                                user: otherUserId, name: "Bob",
-                            }),
-                            USER_MEMBERSHIP_EVENT,
-                            utils.mkEvent({
-                                type: "m.room.create", room: roomId, user: userId,
-                                content: {
-                                    creator: userId,
-                                },
-                            }),
-                        ],
-                    },
-                },
-            },
-        },
-    };
-
-    function setNextSyncData(events) {
-        events = events || [];
-        NEXT_SYNC_DATA = {
-            next_batch: "n",
-            presence: { events: [] },
-            rooms: {
-                invite: {},
-                join: {
-                    "!foo:bar": {
-                        timeline: { events: [] },
-                        state: { events: [] },
-                        ephemeral: { events: [] },
-                    },
-                },
-                leave: {},
-            },
-        };
-        events.forEach(function(e) {
-            if (e.room_id !== roomId) {
-                throw new Error("setNextSyncData only works with one room id");
-            }
-            if (e.state_key) {
-                if (e.__prev_event === undefined) {
-                    throw new Error(
-                        "setNextSyncData needs the prev state set to '__prev_event' " +
-                        "for " + e.type,
-                    );
-                }
-                if (e.__prev_event !== null) {
-                    // push the previous state for this event type
-                    NEXT_SYNC_DATA.rooms.join[roomId].state.events.push(e.__prev_event);
-                }
-                // push the current
-                NEXT_SYNC_DATA.rooms.join[roomId].timeline.events.push(e);
-            } else if (["m.typing", "m.receipt"].indexOf(e.type) !== -1) {
-                NEXT_SYNC_DATA.rooms.join[roomId].ephemeral.events.push(e);
-            } else {
-                NEXT_SYNC_DATA.rooms.join[roomId].timeline.events.push(e);
-            }
-        });
-    }
-
-    beforeEach(async function() {
-        // these tests should work with or without timelineSupport
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { timelineSupport: true },
-        );
-        httpBackend = testClient.httpBackend;
-        client = testClient.client;
-
-        setNextSyncData();
-        httpBackend.when("GET", "/versions").respond(200, {});
-        httpBackend.when("GET", "/pushrules").respond(200, {});
-        httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
-        httpBackend.when("GET", "/sync").respond(200, SYNC_DATA);
-        httpBackend.when("GET", "/sync").respond(200, function() {
-            return NEXT_SYNC_DATA;
-        });
-        client.startClient();
-
-        await httpBackend.flush("/versions");
-        await httpBackend.flush("/pushrules");
-        await httpBackend.flush("/filter");
-    });
-
-    afterEach(function() {
-        httpBackend.verifyNoOutstandingExpectation();
-        client.stopClient();
-        return httpBackend.stop();
-    });
-
-    describe("local echo events", function() {
-        it("should be added immediately after calling MatrixClient.sendEvent " +
-        "with EventStatus.SENDING and the right event.sender", function(done) {
-            client.on("sync", function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client.getRoom(roomId);
-                expect(room.timeline.length).toEqual(1);
-
-                client.sendTextMessage(roomId, "I am a fish", "txn1");
-                // check it was added
-                expect(room.timeline.length).toEqual(2);
-                // check status
-                expect(room.timeline[1].status).toEqual(EventStatus.SENDING);
-                // check member
-                const member = room.timeline[1].sender;
-                expect(member.userId).toEqual(userId);
-                expect(member.name).toEqual(userName);
-
-                httpBackend.flush("/sync", 1).then(function() {
-                    done();
-                });
-            });
-            httpBackend.flush("/sync", 1);
-        });
-
-        it("should be updated correctly when the send request finishes " +
-        "BEFORE the event comes down the event stream", function(done) {
-            const eventId = "$foo:bar";
-            httpBackend.when("PUT", "/txn1").respond(200, {
-                event_id: eventId,
-            });
-
-            const ev = utils.mkMessage({
-                body: "I am a fish", user: userId, room: roomId,
-            });
-            ev.event_id = eventId;
-            ev.unsigned = { transaction_id: "txn1" };
-            setNextSyncData([ev]);
-
-            client.on("sync", function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client.getRoom(roomId);
-                client.sendTextMessage(roomId, "I am a fish", "txn1").then(
-                function() {
-                    expect(room.timeline[1].getId()).toEqual(eventId);
-                    httpBackend.flush("/sync", 1).then(function() {
-                        expect(room.timeline[1].getId()).toEqual(eventId);
-                        done();
-                    });
-                });
-                httpBackend.flush("/txn1", 1);
-            });
-            httpBackend.flush("/sync", 1);
-        });
-
-        it("should be updated correctly when the send request finishes " +
-        "AFTER the event comes down the event stream", function(done) {
-            const eventId = "$foo:bar";
-            httpBackend.when("PUT", "/txn1").respond(200, {
-                event_id: eventId,
-            });
-
-            const ev = utils.mkMessage({
-                body: "I am a fish", user: userId, room: roomId,
-            });
-            ev.event_id = eventId;
-            ev.unsigned = { transaction_id: "txn1" };
-            setNextSyncData([ev]);
-
-            client.on("sync", function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client.getRoom(roomId);
-                const promise = client.sendTextMessage(roomId, "I am a fish", "txn1");
-                httpBackend.flush("/sync", 1).then(function() {
-                    expect(room.timeline.length).toEqual(2);
-                    httpBackend.flush("/txn1", 1);
-                    promise.then(function() {
-                        expect(room.timeline.length).toEqual(2);
-                        expect(room.timeline[1].getId()).toEqual(eventId);
-                        done();
-                    });
-                });
-            });
-            httpBackend.flush("/sync", 1);
-        });
-    });
-
-    describe("paginated events", function() {
-        let sbEvents;
-        const sbEndTok = "pagin_end";
-
-        beforeEach(function() {
-            sbEvents = [];
-            httpBackend.when("GET", "/messages").respond(200, function() {
-                return {
-                    chunk: sbEvents,
-                    start: "pagin_start",
-                    end: sbEndTok,
-                };
-            });
-        });
-
-        it("should set Room.oldState.paginationToken to null at the start" +
-        " of the timeline.", function(done) {
-            client.on("sync", function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client.getRoom(roomId);
-                expect(room.timeline.length).toEqual(1);
-
-                client.scrollback(room).then(function() {
-                    expect(room.timeline.length).toEqual(1);
-                    expect(room.oldState.paginationToken).toBe(null);
-
-                    // still have a sync to flush
-                    httpBackend.flush("/sync", 1).then(() => {
-                        done();
-                    });
-                });
-
-                httpBackend.flush("/messages", 1);
-            });
-            httpBackend.flush("/sync", 1);
-        });
-
-        it("should set the right event.sender values", function(done) {
-            // We're aiming for an eventual timeline of:
-            //
-            // 'Old Alice' joined the room
-            // <Old Alice> I'm old alice
-            // @alice:localhost changed their name from 'Old Alice' to 'Alice'
-            // <Alice> I'm alice
-            // ------^ /messages results above this point, /sync result below
-            // <Bob> hello
-
-            // make an m.room.member event for alice's join
-            const joinMshipEvent = utils.mkMembership({
-                mship: "join", user: userId, room: roomId, name: "Old Alice",
-                url: null,
-            });
-
-            // make an m.room.member event with prev_content for alice's nick
-            // change
-            const oldMshipEvent = utils.mkMembership({
-                mship: "join", user: userId, room: roomId, name: userName,
-                url: "mxc://some/url",
-            });
-            oldMshipEvent.prev_content = {
-                displayname: "Old Alice",
-                avatar_url: null,
-                membership: "join",
-            };
-
-            // set the list of events to return on scrollback (/messages)
-            // N.B. synapse returns /messages in reverse chronological order
-            sbEvents = [
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I'm alice",
-                }),
-                oldMshipEvent,
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I'm old alice",
-                }),
-                joinMshipEvent,
-            ];
-
-            client.on("sync", function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client.getRoom(roomId);
-                // sync response
-                expect(room.timeline.length).toEqual(1);
-
-                client.scrollback(room).then(function() {
-                    expect(room.timeline.length).toEqual(5);
-                    const joinMsg = room.timeline[0];
-                    expect(joinMsg.sender.name).toEqual("Old Alice");
-                    const oldMsg = room.timeline[1];
-                    expect(oldMsg.sender.name).toEqual("Old Alice");
-                    const newMsg = room.timeline[3];
-                    expect(newMsg.sender.name).toEqual(userName);
-
-                    // still have a sync to flush
-                    httpBackend.flush("/sync", 1).then(() => {
-                        done();
-                    });
-                });
-
-                httpBackend.flush("/messages", 1);
-            });
-            httpBackend.flush("/sync", 1);
-        });
-
-        it("should add it them to the right place in the timeline", function(done) {
-            // set the list of events to return on scrollback
-            sbEvents = [
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I am new",
-                }),
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I am old",
-                }),
-            ];
-
-            client.on("sync", function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client.getRoom(roomId);
-                expect(room.timeline.length).toEqual(1);
-
-                client.scrollback(room).then(function() {
-                    expect(room.timeline.length).toEqual(3);
-                    expect(room.timeline[0].event).toEqual(sbEvents[1]);
-                    expect(room.timeline[1].event).toEqual(sbEvents[0]);
-
-                    // still have a sync to flush
-                    httpBackend.flush("/sync", 1).then(() => {
-                        done();
-                    });
-                });
-
-                httpBackend.flush("/messages", 1);
-            });
-            httpBackend.flush("/sync", 1);
-        });
-
-        it("should use 'end' as the next pagination token", function(done) {
-            // set the list of events to return on scrollback
-            sbEvents = [
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I am new",
-                }),
-            ];
-
-            client.on("sync", function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client.getRoom(roomId);
-                expect(room.oldState.paginationToken).toBeTruthy();
-
-                client.scrollback(room, 1).then(function() {
-                    expect(room.oldState.paginationToken).toEqual(sbEndTok);
-                });
-
-                httpBackend.flush("/messages", 1).then(function() {
-                    // still have a sync to flush
-                    httpBackend.flush("/sync", 1).then(() => {
-                        done();
-                    });
-                });
-            });
-            httpBackend.flush("/sync", 1);
-        });
-    });
-
-    describe("new events", function() {
-        it("should be added to the right place in the timeline", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(eventData);
-
-            return Promise.all([
-                httpBackend.flush("/sync", 1),
-                utils.syncPromise(client),
-            ]).then(() => {
-                const room = client.getRoom(roomId);
-
-                let index = 0;
-                client.on("Room.timeline", function(event, rm, toStart) {
-                    expect(toStart).toBe(false);
-                    expect(rm).toEqual(room);
-                    expect(event.event).toEqual(eventData[index]);
-                    index += 1;
-                });
-
-                httpBackend.flush("/messages", 1);
-                return Promise.all([
-                    httpBackend.flush("/sync", 1),
-                    utils.syncPromise(client),
-                ]).then(function() {
-                    expect(index).toEqual(2);
-                    expect(room.timeline.length).toEqual(3);
-                    expect(room.timeline[2].event).toEqual(
-                        eventData[1],
-                    );
-                    expect(room.timeline[1].event).toEqual(
-                        eventData[0],
-                    );
-                });
-            });
-        });
-
-        it("should set the right event.sender values", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-                utils.mkMembership({
-                    user: userId, room: roomId, mship: "join", name: "New Name",
-                }),
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            eventData[1].__prev_event = USER_MEMBERSHIP_EVENT;
-            setNextSyncData(eventData);
-
-            return Promise.all([
-                httpBackend.flush("/sync", 1),
-                utils.syncPromise(client),
-            ]).then(() => {
-                const room = client.getRoom(roomId);
-                return Promise.all([
-                    httpBackend.flush("/sync", 1),
-                    utils.syncPromise(client),
-                ]).then(function() {
-                    const preNameEvent = room.timeline[room.timeline.length - 3];
-                    const postNameEvent = room.timeline[room.timeline.length - 1];
-                    expect(preNameEvent.sender.name).toEqual(userName);
-                    expect(postNameEvent.sender.name).toEqual("New Name");
-                });
-            });
-        });
-
-        it("should set the right room.name", function() {
-            const secondRoomNameEvent = utils.mkEvent({
-                user: userId, room: roomId, type: "m.room.name", content: {
-                    name: "Room 2",
-                },
-            });
-            secondRoomNameEvent.__prev_event = ROOM_NAME_EVENT;
-            setNextSyncData([secondRoomNameEvent]);
-
-            return Promise.all([
-                httpBackend.flush("/sync", 1),
-                utils.syncPromise(client),
-            ]).then(() => {
-                const room = client.getRoom(roomId);
-                let nameEmitCount = 0;
-                client.on("Room.name", function(rm) {
-                    nameEmitCount += 1;
-                });
-
-                return Promise.all([
-                    httpBackend.flush("/sync", 1),
-                    utils.syncPromise(client),
-                ]).then(function() {
-                    expect(nameEmitCount).toEqual(1);
-                    expect(room.name).toEqual("Room 2");
-                    // do another round
-                    const thirdRoomNameEvent = utils.mkEvent({
-                        user: userId, room: roomId, type: "m.room.name", content: {
-                            name: "Room 3",
-                        },
-                    });
-                    thirdRoomNameEvent.__prev_event = secondRoomNameEvent;
-                    setNextSyncData([thirdRoomNameEvent]);
-                    httpBackend.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-                    return Promise.all([
-                        httpBackend.flush("/sync", 1),
-                        utils.syncPromise(client),
-                    ]);
-                }).then(function() {
-                    expect(nameEmitCount).toEqual(2);
-                    expect(room.name).toEqual("Room 3");
-                });
-            });
-        });
-
-        it("should set the right room members", function() {
-            const userC = "@cee:bar";
-            const userD = "@dee:bar";
-            const eventData = [
-                utils.mkMembership({
-                    user: userC, room: roomId, mship: "join", name: "C",
-                }),
-                utils.mkMembership({
-                    user: userC, room: roomId, mship: "invite", skey: userD,
-                }),
-            ];
-            eventData[0].__prev_event = null;
-            eventData[1].__prev_event = null;
-            setNextSyncData(eventData);
-
-            return Promise.all([
-                httpBackend.flush("/sync", 1),
-                utils.syncPromise(client),
-            ]).then(() => {
-                const room = client.getRoom(roomId);
-                return Promise.all([
-                    httpBackend.flush("/sync", 1),
-                    utils.syncPromise(client),
-                ]).then(function() {
-                    expect(room.currentState.getMembers().length).toEqual(4);
-                    expect(room.currentState.getMember(userC).name).toEqual("C");
-                    expect(room.currentState.getMember(userC).membership).toEqual(
-                        "join",
-                    );
-                    expect(room.currentState.getMember(userD).name).toEqual(userD);
-                    expect(room.currentState.getMember(userD).membership).toEqual(
-                        "invite",
-                    );
-                });
-            });
-        });
-    });
-
-    describe("gappy sync", function() {
-        it("should copy the last known state to the new timeline", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(eventData);
-            NEXT_SYNC_DATA.rooms.join[roomId].timeline.limited = true;
-
-            return Promise.all([
-                httpBackend.flush("/versions", 1),
-                httpBackend.flush("/sync", 1),
-                utils.syncPromise(client),
-            ]).then(() => {
-                const room = client.getRoom(roomId);
-
-                httpBackend.flush("/messages", 1);
-                return Promise.all([
-                    httpBackend.flush("/sync", 1),
-                    utils.syncPromise(client),
-                ]).then(function() {
-                    expect(room.timeline.length).toEqual(1);
-                    expect(room.timeline[0].event).toEqual(eventData[0]);
-                    expect(room.currentState.getMembers().length).toEqual(2);
-                    expect(room.currentState.getMember(userId).name).toEqual(userName);
-                    expect(room.currentState.getMember(userId).membership).toEqual(
-                        "join",
-                    );
-                    expect(room.currentState.getMember(otherUserId).name).toEqual("Bob");
-                    expect(room.currentState.getMember(otherUserId).membership).toEqual(
-                        "join",
-                    );
-                });
-            });
-        });
-
-        it("should emit a `RoomEvent.TimelineReset` event when the sync response is `limited`", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(eventData);
-            NEXT_SYNC_DATA.rooms.join[roomId].timeline.limited = true;
-
-            return Promise.all([
-                httpBackend.flush("/sync", 1),
-                utils.syncPromise(client),
-            ]).then(() => {
-                const room = client.getRoom(roomId);
-
-                let emitCount = 0;
-                client.on("Room.timelineReset", function(emitRoom) {
-                    expect(emitRoom).toEqual(room);
-                    emitCount++;
-                });
-
-                httpBackend.flush("/messages", 1);
-                return Promise.all([
-                    httpBackend.flush("/sync", 1),
-                    utils.syncPromise(client),
-                ]).then(function() {
-                    expect(emitCount).toEqual(1);
-                });
-            });
-        });
-    });
-
-    describe('Refresh live timeline', () => {
-        const initialSyncEventData = [
-            utils.mkMessage({ user: userId, room: roomId }),
-            utils.mkMessage({ user: userId, room: roomId }),
-            utils.mkMessage({ user: userId, room: roomId }),
-        ];
-
-        const contextUrl = `/rooms/${encodeURIComponent(roomId)}/context/` +
-        `${encodeURIComponent(initialSyncEventData[2].event_id)}`;
-        const contextResponse = {
-            start: "start_token",
-            events_before: [initialSyncEventData[1], initialSyncEventData[0]],
-            event: initialSyncEventData[2],
-            events_after: [],
-            state: [
-                USER_MEMBERSHIP_EVENT,
-            ],
-            end: "end_token",
-        };
-
-        let room;
-        beforeEach(async () => {
-            setNextSyncData(initialSyncEventData);
-
-            // Create a room from the sync
-            await Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client, 1),
-            ]);
-
-            // Get the room after the first sync so the room is created
-            room = client.getRoom(roomId);
-            expect(room).toBeTruthy();
-        });
-
-        it('should clear and refresh messages in timeline', async () => {
-            // `/context` request for `refreshLiveTimeline()` -> `getEventTimeline()`
-            // to construct a new timeline from.
-            httpBackend.when("GET", contextUrl)
-                .respond(200, function() {
-                    // The timeline should be cleared at this point in the refresh
-                    expect(room.timeline.length).toEqual(0);
-
-                    return contextResponse;
-                });
-
-            // Refresh the timeline.
-            await Promise.all([
-                room.refreshLiveTimeline(),
-                httpBackend.flushAllExpected(),
-            ]);
-
-            // Make sure the message are visible
-            const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
-            const resultantEventIdsInTimeline = resultantEventsInTimeline.map((event) => event.getId());
-            expect(resultantEventIdsInTimeline).toEqual([
-                initialSyncEventData[0].event_id,
-                initialSyncEventData[1].event_id,
-                initialSyncEventData[2].event_id,
-            ]);
-        });
-
-        it('Perfectly merges timelines if a sync finishes while refreshing the timeline', async () => {
-            // `/context` request for `refreshLiveTimeline()` ->
-            // `getEventTimeline()` to construct a new timeline from.
-            //
-            // We only resolve this request after we detect that the timeline
-            // was reset(when it goes blank) and force a sync to happen in the
-            // middle of all of this refresh timeline logic. We want to make
-            // sure the sync pagination still works as expected after messing
-            // the refresh timline logic messes with the pagination tokens.
-            httpBackend.when("GET", contextUrl)
-                .respond(200, () => {
-                    // Now finally return and make the `/context` request respond
-                    return contextResponse;
-                });
-
-            // Wait for the timeline to reset(when it goes blank) which means
-            // it's in the middle of the refrsh logic right before the
-            // `getEventTimeline()` -> `/context`. Then simulate a racey `/sync`
-            // to happen in the middle of all of this refresh timeline logic. We
-            // want to make sure the sync pagination still works as expected
-            // after messing the refresh timline logic messes with the
-            // pagination tokens.
-            //
-            // We define this here so the event listener is in place before we
-            // call `room.refreshLiveTimeline()`.
-            const racingSyncEventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            const waitForRaceySyncAfterResetPromise = new Promise((resolve, reject) => {
-                let eventFired = false;
-                // Throw a more descriptive error if this part of the test times out.
-                const failTimeout = setTimeout(() => {
-                    if (eventFired) {
-                        reject(new Error(
-                            'TestError: `RoomEvent.TimelineReset` fired but we timed out trying to make' +
-                            'a `/sync` happen in time.',
-                        ));
-                    } else {
-                        reject(new Error(
-                            'TestError: Timed out while waiting for `RoomEvent.TimelineReset` to fire.',
-                        ));
-                    }
-                }, 4000 /* FIXME: Is there a way to reference the current timeout of this test in Jest? */);
-
-                room.on(RoomEvent.TimelineReset, async () => {
-                    try {
-                        eventFired = true;
-
-                        // The timeline should be cleared at this point in the refresh
-                        expect(room.getUnfilteredTimelineSet().getLiveTimeline().getEvents().length).toEqual(0);
-
-                        // Then make a `/sync` happen by sending a message and seeing that it
-                        // shows up (simulate a /sync naturally racing with us).
-                        setNextSyncData(racingSyncEventData);
-                        httpBackend.when("GET", "/sync").respond(200, function() {
-                            return NEXT_SYNC_DATA;
-                        });
-                        await Promise.all([
-                            httpBackend.flush("/sync", 1),
-                            utils.syncPromise(client, 1),
-                        ]);
-                        // Make sure the timeline has the racey sync data
-                        const afterRaceySyncTimelineEvents = room
-                            .getUnfilteredTimelineSet()
-                            .getLiveTimeline()
-                            .getEvents();
-                        const afterRaceySyncTimelineEventIds = afterRaceySyncTimelineEvents
-                            .map((event) => event.getId());
-                        expect(afterRaceySyncTimelineEventIds).toEqual([
-                            racingSyncEventData[0].event_id,
-                        ]);
-
-                        clearTimeout(failTimeout);
-                        resolve();
-                    } catch (err) {
-                        reject(err);
-                    }
-                });
-            });
-
-            // Refresh the timeline. Just start the function, we will wait for
-            // it to finish after the racey sync.
-            const refreshLiveTimelinePromise = room.refreshLiveTimeline();
-
-            await waitForRaceySyncAfterResetPromise;
-
-            await Promise.all([
-                refreshLiveTimelinePromise,
-                // Then flush the remaining `/context` to left the refresh logic complete
-                httpBackend.flushAllExpected(),
-            ]);
-
-            // Make sure sync pagination still works by seeing a new message show up
-            // after refreshing the timeline.
-            const afterRefreshEventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(afterRefreshEventData);
-            httpBackend.when("GET", "/sync").respond(200, function() {
-                return NEXT_SYNC_DATA;
-            });
-            await Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client, 1),
-            ]);
-
-            // Make sure the timeline includes the the events from the `/sync`
-            // that raced and beat us in the middle of everything and the
-            // `/sync` after the refresh. Since the `/sync` beat us to create
-            // the timeline, `initialSyncEventData` won't be visible unless we
-            // paginate backwards with `/messages`.
-            const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
-            const resultantEventIdsInTimeline = resultantEventsInTimeline.map((event) => event.getId());
-            expect(resultantEventIdsInTimeline).toEqual([
-                racingSyncEventData[0].event_id,
-                afterRefreshEventData[0].event_id,
-            ]);
-        });
-
-        it('Timeline recovers after `/context` request to generate new timeline fails', async () => {
-            // `/context` request for `refreshLiveTimeline()` -> `getEventTimeline()`
-            // to construct a new timeline from.
-            httpBackend.when("GET", contextUrl)
-                .respond(500, function() {
-                    // The timeline should be cleared at this point in the refresh
-                    expect(room.timeline.length).toEqual(0);
-
-                    return {
-                        errcode: 'TEST_FAKE_ERROR',
-                        error: 'We purposely intercepted this /context request to make it fail ' +
-                                 'in order to test whether the refresh timeline code is resilient',
-                    };
-                });
-
-            // Refresh the timeline and expect it to fail
-            const settledFailedRefreshPromises = await Promise.allSettled([
-                room.refreshLiveTimeline(),
-                httpBackend.flushAllExpected(),
-            ]);
-            // We only expect `TEST_FAKE_ERROR` here. Anything else is
-            // unexpected and should fail the test.
-            if (settledFailedRefreshPromises[0].status === 'fulfilled') {
-                throw new Error('Expected the /context request to fail with a 500');
-            } else if (settledFailedRefreshPromises[0].reason.errcode !== 'TEST_FAKE_ERROR') {
-                throw settledFailedRefreshPromises[0].reason;
-            }
-
-            // The timeline will be empty after we refresh the timeline and fail
-            // to construct a new timeline.
-            expect(room.timeline.length).toEqual(0);
-
-            // `/messages` request for `refreshLiveTimeline()` ->
-            // `getLatestTimeline()` to construct a new timeline from.
-            httpBackend.when("GET", `/rooms/${encodeURIComponent(roomId)}/messages`)
-                .respond(200, function() {
-                    return {
-                        chunk: [{
-                            // The latest message in the room
-                            event_id: initialSyncEventData[2].event_id,
-                        }],
-                    };
-                });
-            // `/context` request for `refreshLiveTimeline()` ->
-            // `getLatestTimeline()` -> `getEventTimeline()` to construct a new
-            // timeline from.
-            httpBackend.when("GET", contextUrl)
-                .respond(200, function() {
-                    // The timeline should be cleared at this point in the refresh
-                    expect(room.timeline.length).toEqual(0);
-
-                    return contextResponse;
-                });
-
-            // Refresh the timeline again but this time it should pass
-            await Promise.all([
-                room.refreshLiveTimeline(),
-                httpBackend.flushAllExpected(),
-            ]);
-
-            // Make sure sync pagination still works by seeing a new message show up
-            // after refreshing the timeline.
-            const afterRefreshEventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(afterRefreshEventData);
-            httpBackend.when("GET", "/sync").respond(200, function() {
-                return NEXT_SYNC_DATA;
-            });
-            await Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client, 1),
-            ]);
-
-            // Make sure the message are visible
-            const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
-            const resultantEventIdsInTimeline = resultantEventsInTimeline.map((event) => event.getId());
-            expect(resultantEventIdsInTimeline).toEqual([
-                initialSyncEventData[0].event_id,
-                initialSyncEventData[1].event_id,
-                initialSyncEventData[2].event_id,
-                afterRefreshEventData[0].event_id,
-            ]);
-        });
-    });
-});

spec/integ/matrix-client-room-timeline.spec.ts

@@ -0,0 +1,871 @@
+/*
+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 HttpBackend from "matrix-mock-request";
+
+import * as utils from "../test-utils/test-utils";
+import { EventStatus } from "../../src/models/event";
+import {
+    MatrixError,
+    ClientEvent,
+    IEvent,
+    MatrixClient,
+    RoomEvent,
+    ISyncResponse,
+    IMinimalEvent,
+    IRoomEvent,
+    Room,
+} from "../../src";
+import { TestClient } from "../TestClient";
+
+describe("MatrixClient room timelines", function () {
+    const userId = "@alice:localhost";
+    const userName = "Alice";
+    const accessToken = "aseukfgwef";
+    const roomId = "!foo:bar";
+    const otherUserId = "@bob:localhost";
+    let client: MatrixClient | undefined;
+    let httpBackend: HttpBackend | undefined;
+
+    const USER_MEMBERSHIP_EVENT = utils.mkMembership({
+        room: roomId,
+        mship: "join",
+        user: userId,
+        name: userName,
+    });
+    const ROOM_NAME_EVENT = utils.mkEvent({
+        type: "m.room.name",
+        room: roomId,
+        user: otherUserId,
+        content: {
+            name: "Old room name",
+        },
+    });
+    let NEXT_SYNC_DATA: Partial<ISyncResponse>;
+    const SYNC_DATA = {
+        next_batch: "s_5_3",
+        rooms: {
+            join: {
+                "!foo:bar": {
+                    // roomId
+                    timeline: {
+                        events: [
+                            utils.mkMessage({
+                                room: roomId,
+                                user: otherUserId,
+                                msg: "hello",
+                            }),
+                        ],
+                        prev_batch: "f_1_1",
+                    },
+                    state: {
+                        events: [
+                            ROOM_NAME_EVENT,
+                            utils.mkMembership({
+                                room: roomId,
+                                mship: "join",
+                                user: otherUserId,
+                                name: "Bob",
+                            }),
+                            USER_MEMBERSHIP_EVENT,
+                            utils.mkEvent({
+                                type: "m.room.create",
+                                room: roomId,
+                                user: userId,
+                                content: {
+                                    creator: userId,
+                                },
+                            }),
+                        ],
+                    },
+                },
+            },
+        },
+    };
+
+    function setNextSyncData(events: Partial<IEvent>[] = []) {
+        NEXT_SYNC_DATA = {
+            next_batch: "n",
+            presence: { events: [] },
+            rooms: {
+                invite: {},
+                join: {
+                    "!foo:bar": {
+                        timeline: { events: [] },
+                        state: { events: [] },
+                        ephemeral: { events: [] },
+                    },
+                },
+                leave: {},
+            } as unknown as ISyncResponse["rooms"],
+        };
+        events.forEach(function (e) {
+            if (e.room_id !== roomId) {
+                throw new Error("setNextSyncData only works with one room id");
+            }
+            if (e.state_key) {
+                // push the current
+                NEXT_SYNC_DATA.rooms!.join[roomId].timeline.events.push(e as unknown as IRoomEvent);
+            } else if (["m.typing", "m.receipt"].indexOf(e.type!) !== -1) {
+                NEXT_SYNC_DATA.rooms!.join[roomId].ephemeral.events.push(e as unknown as IMinimalEvent);
+            } else {
+                NEXT_SYNC_DATA.rooms!.join[roomId].timeline.events.push(e as unknown as IRoomEvent);
+            }
+        });
+    }
+
+    const setupTestClient = (): [MatrixClient, HttpBackend] => {
+        // these tests should work with or without timelineSupport
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { timelineSupport: true });
+        const httpBackend = testClient.httpBackend;
+        const client = testClient.client;
+
+        setNextSyncData();
+        httpBackend!.when("GET", "/versions").respond(200, {});
+        httpBackend!.when("GET", "/pushrules").respond(200, {});
+        httpBackend!.when("POST", "/filter").respond(200, { filter_id: "fid" });
+        httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
+        httpBackend!.when("GET", "/sync").respond(200, function () {
+            return NEXT_SYNC_DATA;
+        });
+        client!.startClient();
+
+        return [client!, httpBackend];
+    };
+
+    beforeEach(async function () {
+        [client!, httpBackend] = setupTestClient();
+        await httpBackend.flush("/versions");
+        await httpBackend.flush("/pushrules");
+        await httpBackend.flush("/filter");
+    });
+
+    afterEach(function () {
+        httpBackend!.verifyNoOutstandingExpectation();
+        client!.stopClient();
+        return httpBackend!.stop();
+    });
+
+    describe("local echo events", function () {
+        it(
+            "should be added immediately after calling MatrixClient.sendEvent " +
+                "with EventStatus.SENDING and the right event.sender",
+            function (done) {
+                client!.on(ClientEvent.Sync, function (state) {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    expect(room.timeline.length).toEqual(1);
+
+                    client!.sendTextMessage(roomId, "I am a fish", "txn1");
+                    // check it was added
+                    expect(room.timeline.length).toEqual(2);
+                    // check status
+                    expect(room.timeline[1].status).toEqual(EventStatus.SENDING);
+                    // check member
+                    const member = room.timeline[1].sender;
+                    expect(member?.userId).toEqual(userId);
+                    expect(member?.name).toEqual(userName);
+
+                    httpBackend!.flush("/sync", 1).then(function () {
+                        done();
+                    });
+                });
+                httpBackend!.flush("/sync", 1);
+            },
+        );
+
+        it(
+            "should be updated correctly when the send request finishes " +
+                "BEFORE the event comes down the event stream",
+            function (done) {
+                const eventId = "$foo:bar";
+                httpBackend!.when("PUT", "/txn1").respond(200, {
+                    event_id: eventId,
+                });
+
+                const ev = utils.mkMessage({
+                    msg: "I am a fish",
+                    user: userId,
+                    room: roomId,
+                });
+                ev.event_id = eventId;
+                ev.unsigned = { transaction_id: "txn1" };
+                setNextSyncData([ev]);
+
+                client!.on(ClientEvent.Sync, function (state) {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    client!.sendTextMessage(roomId, "I am a fish", "txn1").then(function () {
+                        expect(room.timeline[1].getId()).toEqual(eventId);
+                        httpBackend!.flush("/sync", 1).then(function () {
+                            expect(room.timeline[1].getId()).toEqual(eventId);
+                            done();
+                        });
+                    });
+                    httpBackend!.flush("/txn1", 1);
+                });
+                httpBackend!.flush("/sync", 1);
+            },
+        );
+
+        it(
+            "should be updated correctly when the send request finishes " +
+                "AFTER the event comes down the event stream",
+            function (done) {
+                const eventId = "$foo:bar";
+                httpBackend!.when("PUT", "/txn1").respond(200, {
+                    event_id: eventId,
+                });
+
+                const ev = utils.mkMessage({
+                    msg: "I am a fish",
+                    user: userId,
+                    room: roomId,
+                });
+                ev.event_id = eventId;
+                ev.unsigned = { transaction_id: "txn1" };
+                setNextSyncData([ev]);
+
+                client!.on(ClientEvent.Sync, function (state) {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    const promise = client!.sendTextMessage(roomId, "I am a fish", "txn1");
+                    httpBackend!.flush("/sync", 1).then(function () {
+                        expect(room.timeline.length).toEqual(2);
+                        httpBackend!.flush("/txn1", 1);
+                        promise.then(function () {
+                            expect(room.timeline.length).toEqual(2);
+                            expect(room.timeline[1].getId()).toEqual(eventId);
+                            done();
+                        });
+                    });
+                });
+                httpBackend!.flush("/sync", 1);
+            },
+        );
+    });
+
+    describe("paginated events", function () {
+        let sbEvents: Partial<IEvent>[];
+        const sbEndTok = "pagin_end";
+
+        beforeEach(function () {
+            sbEvents = [];
+            httpBackend!.when("GET", "/messages").respond(200, function () {
+                return {
+                    chunk: sbEvents,
+                    start: "pagin_start",
+                    end: sbEndTok,
+                };
+            });
+        });
+
+        it("should set Room.oldState.paginationToken to null at the start" + " of the timeline.", function (done) {
+            client!.on(ClientEvent.Sync, function (state) {
+                if (state !== "PREPARED") {
+                    return;
+                }
+                const room = client!.getRoom(roomId)!;
+                expect(room.timeline.length).toEqual(1);
+
+                client!.scrollback(room).then(function () {
+                    expect(room.timeline.length).toEqual(1);
+                    expect(room.oldState.paginationToken).toBe(null);
+
+                    // still have a sync to flush
+                    httpBackend!.flush("/sync", 1).then(() => {
+                        done();
+                    });
+                });
+
+                httpBackend!.flush("/messages", 1);
+            });
+            httpBackend!.flush("/sync", 1);
+        });
+
+        it("should set the right event.sender values", function (done) {
+            // We're aiming for an eventual timeline of:
+            //
+            // 'Old Alice' joined the room
+            // <Old Alice> I'm old alice
+            // @alice:localhost changed their name from 'Old Alice' to 'Alice'
+            // <Alice> I'm alice
+            // ------^ /messages results above this point, /sync result below
+            // <Bob> hello
+
+            // make an m.room.member event for alice's join
+            const joinMshipEvent = utils.mkMembership({
+                mship: "join",
+                user: userId,
+                room: roomId,
+                name: "Old Alice",
+                url: undefined,
+            });
+
+            // make an m.room.member event with prev_content for alice's nick
+            // change
+            const oldMshipEvent = utils.mkMembership({
+                mship: "join",
+                user: userId,
+                room: roomId,
+                name: userName,
+                url: "mxc://some/url",
+            });
+            oldMshipEvent.prev_content = {
+                displayname: "Old Alice",
+                avatar_url: undefined,
+                membership: "join",
+            };
+
+            // set the list of events to return on scrollback (/messages)
+            // N.B. synapse returns /messages in reverse chronological order
+            sbEvents = [
+                utils.mkMessage({
+                    user: userId,
+                    room: roomId,
+                    msg: "I'm alice",
+                }),
+                oldMshipEvent,
+                utils.mkMessage({
+                    user: userId,
+                    room: roomId,
+                    msg: "I'm old alice",
+                }),
+                joinMshipEvent,
+            ];
+
+            client!.on(ClientEvent.Sync, function (state) {
+                if (state !== "PREPARED") {
+                    return;
+                }
+                const room = client!.getRoom(roomId)!;
+                // sync response
+                expect(room.timeline.length).toEqual(1);
+
+                client!.scrollback(room).then(function () {
+                    expect(room.timeline.length).toEqual(5);
+                    const joinMsg = room.timeline[0];
+                    expect(joinMsg.sender?.name).toEqual("Old Alice");
+                    const oldMsg = room.timeline[1];
+                    expect(oldMsg.sender?.name).toEqual("Old Alice");
+                    const newMsg = room.timeline[3];
+                    expect(newMsg.sender?.name).toEqual(userName);
+
+                    // still have a sync to flush
+                    httpBackend!.flush("/sync", 1).then(() => {
+                        done();
+                    });
+                });
+
+                httpBackend!.flush("/messages", 1);
+            });
+            httpBackend!.flush("/sync", 1);
+        });
+
+        it("should add it them to the right place in the timeline", function (done) {
+            // set the list of events to return on scrollback
+            sbEvents = [
+                utils.mkMessage({
+                    user: userId,
+                    room: roomId,
+                    msg: "I am new",
+                }),
+                utils.mkMessage({
+                    user: userId,
+                    room: roomId,
+                    msg: "I am old",
+                }),
+            ];
+
+            client!.on(ClientEvent.Sync, function (state) {
+                if (state !== "PREPARED") {
+                    return;
+                }
+                const room = client!.getRoom(roomId)!;
+                expect(room.timeline.length).toEqual(1);
+
+                client!.scrollback(room).then(function () {
+                    expect(room.timeline.length).toEqual(3);
+                    expect(room.timeline[0].event).toEqual(sbEvents[1]);
+                    expect(room.timeline[1].event).toEqual(sbEvents[0]);
+
+                    // still have a sync to flush
+                    httpBackend!.flush("/sync", 1).then(() => {
+                        done();
+                    });
+                });
+
+                httpBackend!.flush("/messages", 1);
+            });
+            httpBackend!.flush("/sync", 1);
+        });
+
+        it("should use 'end' as the next pagination token", function (done) {
+            // set the list of events to return on scrollback
+            sbEvents = [
+                utils.mkMessage({
+                    user: userId,
+                    room: roomId,
+                    msg: "I am new",
+                }),
+            ];
+
+            client!.on(ClientEvent.Sync, function (state) {
+                if (state !== "PREPARED") {
+                    return;
+                }
+                const room = client!.getRoom(roomId)!;
+                expect(room.oldState.paginationToken).toBeTruthy();
+
+                client!.scrollback(room, 1).then(function () {
+                    expect(room.oldState.paginationToken).toEqual(sbEndTok);
+                });
+
+                httpBackend!.flush("/messages", 1).then(function () {
+                    // still have a sync to flush
+                    httpBackend!.flush("/sync", 1).then(() => {
+                        done();
+                    });
+                });
+            });
+            httpBackend!.flush("/sync", 1);
+        });
+    });
+
+    describe("new events", function () {
+        it("should be added to the right place in the timeline", function () {
+            const eventData = [
+                utils.mkMessage({ user: userId, room: roomId }),
+                utils.mkMessage({ user: userId, room: roomId }),
+            ];
+            setNextSyncData(eventData);
+
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
+                const room = client!.getRoom(roomId)!;
+
+                let index = 0;
+                client!.on(RoomEvent.Timeline, function (event, rm, toStart) {
+                    expect(toStart).toBe(false);
+                    expect(rm).toEqual(room);
+                    expect(event.event).toEqual(eventData[index]);
+                    index += 1;
+                });
+
+                httpBackend!.flush("/messages", 1);
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
+                    expect(index).toEqual(2);
+                    expect(room.timeline.length).toEqual(3);
+                    expect(room.timeline[2].event).toEqual(eventData[1]);
+                    expect(room.timeline[1].event).toEqual(eventData[0]);
+                });
+            });
+        });
+
+        it("should set the right event.sender values", function () {
+            const eventData = [
+                utils.mkMessage({ user: userId, room: roomId }),
+                utils.mkMembership({
+                    user: userId,
+                    room: roomId,
+                    mship: "join",
+                    name: "New Name",
+                }),
+                utils.mkMessage({ user: userId, room: roomId }),
+            ];
+            setNextSyncData(eventData);
+
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
+                const room = client!.getRoom(roomId)!;
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
+                    const preNameEvent = room.timeline[room.timeline.length - 3];
+                    const postNameEvent = room.timeline[room.timeline.length - 1];
+                    expect(preNameEvent.sender?.name).toEqual(userName);
+                    expect(postNameEvent.sender?.name).toEqual("New Name");
+                });
+            });
+        });
+
+        it("should set the right room.name", function () {
+            const secondRoomNameEvent = utils.mkEvent({
+                user: userId,
+                room: roomId,
+                type: "m.room.name",
+                content: {
+                    name: "Room 2",
+                },
+            });
+            setNextSyncData([secondRoomNameEvent]);
+
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
+                const room = client!.getRoom(roomId)!;
+                let nameEmitCount = 0;
+                client!.on(RoomEvent.Name, function (rm) {
+                    nameEmitCount += 1;
+                });
+
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)])
+                    .then(function () {
+                        expect(nameEmitCount).toEqual(1);
+                        expect(room.name).toEqual("Room 2");
+                        // do another round
+                        const thirdRoomNameEvent = utils.mkEvent({
+                            user: userId,
+                            room: roomId,
+                            type: "m.room.name",
+                            content: {
+                                name: "Room 3",
+                            },
+                        });
+                        setNextSyncData([thirdRoomNameEvent]);
+                        httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+                        return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]);
+                    })
+                    .then(function () {
+                        expect(nameEmitCount).toEqual(2);
+                        expect(room.name).toEqual("Room 3");
+                    });
+            });
+        });
+
+        it("should set the right room members", function () {
+            const userC = "@cee:bar";
+            const userD = "@dee:bar";
+            const eventData = [
+                utils.mkMembership({
+                    user: userC,
+                    room: roomId,
+                    mship: "join",
+                    name: "C",
+                }),
+                utils.mkMembership({
+                    user: userC,
+                    room: roomId,
+                    mship: "invite",
+                    skey: userD,
+                }),
+            ];
+            setNextSyncData(eventData);
+
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
+                const room = client!.getRoom(roomId)!;
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
+                    expect(room.currentState.getMembers().length).toEqual(4);
+                    expect(room.currentState.getMember(userC)!.name).toEqual("C");
+                    expect(room.currentState.getMember(userC)!.membership).toEqual("join");
+                    expect(room.currentState.getMember(userD)!.name).toEqual(userD);
+                    expect(room.currentState.getMember(userD)!.membership).toEqual("invite");
+                });
+            });
+        });
+    });
+
+    describe("gappy sync", function () {
+        it("should copy the last known state to the new timeline", function () {
+            const eventData = [utils.mkMessage({ user: userId, room: roomId })];
+            setNextSyncData(eventData);
+            NEXT_SYNC_DATA.rooms!.join[roomId].timeline.limited = true;
+
+            return Promise.all([
+                httpBackend!.flush("/versions", 1),
+                httpBackend!.flush("/sync", 1),
+                utils.syncPromise(client!),
+            ]).then(() => {
+                const room = client!.getRoom(roomId)!;
+
+                httpBackend!.flush("/messages", 1);
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
+                    expect(room.timeline.length).toEqual(1);
+                    expect(room.timeline[0].event).toEqual(eventData[0]);
+                    expect(room.currentState.getMembers().length).toEqual(2);
+                    expect(room.currentState.getMember(userId)!.name).toEqual(userName);
+                    expect(room.currentState.getMember(userId)!.membership).toEqual("join");
+                    expect(room.currentState.getMember(otherUserId)!.name).toEqual("Bob");
+                    expect(room.currentState.getMember(otherUserId)!.membership).toEqual("join");
+                });
+            });
+        });
+
+        it("should emit a `RoomEvent.TimelineReset` event when the sync response is `limited`", function () {
+            const eventData = [utils.mkMessage({ user: userId, room: roomId })];
+            setNextSyncData(eventData);
+            NEXT_SYNC_DATA.rooms!.join[roomId].timeline.limited = true;
+
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
+                const room = client!.getRoom(roomId)!;
+
+                let emitCount = 0;
+                client!.on(RoomEvent.TimelineReset, function (emitRoom) {
+                    expect(emitRoom).toEqual(room);
+                    emitCount++;
+                });
+
+                httpBackend!.flush("/messages", 1);
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
+                    expect(emitCount).toEqual(1);
+                });
+            });
+        });
+    });
+
+    describe("Refresh live timeline", () => {
+        const initialSyncEventData = [
+            utils.mkMessage({ user: userId, room: roomId }),
+            utils.mkMessage({ user: userId, room: roomId }),
+            utils.mkMessage({ user: userId, room: roomId }),
+        ];
+
+        const contextUrl =
+            `/rooms/${encodeURIComponent(roomId)}/context/` +
+            `${encodeURIComponent(initialSyncEventData[2].event_id!)}`;
+        const contextResponse = {
+            start: "start_token",
+            events_before: [initialSyncEventData[1], initialSyncEventData[0]],
+            event: initialSyncEventData[2],
+            events_after: [],
+            state: [USER_MEMBERSHIP_EVENT],
+            end: "end_token",
+        };
+
+        let room: Room;
+        beforeEach(async () => {
+            setNextSyncData(initialSyncEventData);
+
+            // Create a room from the sync
+            await Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 1)]);
+
+            // Get the room after the first sync so the room is created
+            room = client!.getRoom(roomId)!;
+            expect(room).toBeTruthy();
+        });
+
+        it("should clear and refresh messages in timeline", async () => {
+            // `/context` request for `refreshLiveTimeline()` -> `getEventTimeline()`
+            // to construct a new timeline from.
+            httpBackend!.when("GET", contextUrl).respond(200, function () {
+                // The timeline should be cleared at this point in the refresh
+                expect(room.timeline.length).toEqual(0);
+
+                return contextResponse;
+            });
+
+            // Refresh the timeline.
+            await Promise.all([room.refreshLiveTimeline(), httpBackend!.flushAllExpected()]);
+
+            // Make sure the message are visible
+            const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
+            const resultantEventIdsInTimeline = resultantEventsInTimeline.map((event) => event.getId());
+            expect(resultantEventIdsInTimeline).toEqual([
+                initialSyncEventData[0].event_id,
+                initialSyncEventData[1].event_id,
+                initialSyncEventData[2].event_id,
+            ]);
+        });
+
+        it("Perfectly merges timelines if a sync finishes while refreshing the timeline", async () => {
+            // `/context` request for `refreshLiveTimeline()` ->
+            // `getEventTimeline()` to construct a new timeline from.
+            //
+            // We only resolve this request after we detect that the timeline
+            // was reset(when it goes blank) and force a sync to happen in the
+            // middle of all of this refresh timeline logic. We want to make
+            // sure the sync pagination still works as expected after messing
+            // the refresh timline logic messes with the pagination tokens.
+            httpBackend!.when("GET", contextUrl).respond(200, () => {
+                // Now finally return and make the `/context` request respond
+                return contextResponse;
+            });
+
+            // Wait for the timeline to reset(when it goes blank) which means
+            // it's in the middle of the refrsh logic right before the
+            // `getEventTimeline()` -> `/context`. Then simulate a racey `/sync`
+            // to happen in the middle of all of this refresh timeline logic. We
+            // want to make sure the sync pagination still works as expected
+            // after messing the refresh timline logic messes with the
+            // pagination tokens.
+            //
+            // We define this here so the event listener is in place before we
+            // call `room.refreshLiveTimeline()`.
+            const racingSyncEventData = [utils.mkMessage({ user: userId, room: roomId })];
+            const waitForRaceySyncAfterResetPromise = new Promise<void>((resolve, reject) => {
+                let eventFired = false;
+                // Throw a more descriptive error if this part of the test times out.
+                const failTimeout = setTimeout(() => {
+                    if (eventFired) {
+                        reject(
+                            new Error(
+                                "TestError: `RoomEvent.TimelineReset` fired but we timed out trying to make" +
+                                    "a `/sync` happen in time.",
+                            ),
+                        );
+                    } else {
+                        reject(new Error("TestError: Timed out while waiting for `RoomEvent.TimelineReset` to fire."));
+                    }
+                }, 4000 /* FIXME: Is there a way to reference the current timeout of this test in Jest? */);
+
+                room.on(RoomEvent.TimelineReset, async () => {
+                    try {
+                        eventFired = true;
+
+                        // The timeline should be cleared at this point in the refresh
+                        expect(room.getUnfilteredTimelineSet().getLiveTimeline().getEvents().length).toEqual(0);
+
+                        // Then make a `/sync` happen by sending a message and seeing that it
+                        // shows up (simulate a /sync naturally racing with us).
+                        setNextSyncData(racingSyncEventData);
+                        httpBackend!.when("GET", "/sync").respond(200, function () {
+                            return NEXT_SYNC_DATA;
+                        });
+                        await Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!, 1)]);
+                        // Make sure the timeline has the racey sync data
+                        const afterRaceySyncTimelineEvents = room
+                            .getUnfilteredTimelineSet()
+                            .getLiveTimeline()
+                            .getEvents();
+                        const afterRaceySyncTimelineEventIds = afterRaceySyncTimelineEvents.map((event) =>
+                            event.getId(),
+                        );
+                        expect(afterRaceySyncTimelineEventIds).toEqual([racingSyncEventData[0].event_id]);
+
+                        clearTimeout(failTimeout);
+                        resolve();
+                    } catch (err) {
+                        reject(err);
+                    }
+                });
+            });
+
+            // Refresh the timeline. Just start the function, we will wait for
+            // it to finish after the racey sync.
+            const refreshLiveTimelinePromise = room.refreshLiveTimeline();
+
+            await waitForRaceySyncAfterResetPromise;
+
+            await Promise.all([
+                refreshLiveTimelinePromise,
+                // Then flush the remaining `/context` to left the refresh logic complete
+                httpBackend!.flushAllExpected(),
+            ]);
+
+            // Make sure sync pagination still works by seeing a new message show up
+            // after refreshing the timeline.
+            const afterRefreshEventData = [utils.mkMessage({ user: userId, room: roomId })];
+            setNextSyncData(afterRefreshEventData);
+            httpBackend!.when("GET", "/sync").respond(200, function () {
+                return NEXT_SYNC_DATA;
+            });
+            await Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 1)]);
+
+            // Make sure the timeline includes the the events from the `/sync`
+            // that raced and beat us in the middle of everything and the
+            // `/sync` after the refresh. Since the `/sync` beat us to create
+            // the timeline, `initialSyncEventData` won't be visible unless we
+            // paginate backwards with `/messages`.
+            const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
+            const resultantEventIdsInTimeline = resultantEventsInTimeline.map((event) => event.getId());
+            expect(resultantEventIdsInTimeline).toEqual([
+                racingSyncEventData[0].event_id,
+                afterRefreshEventData[0].event_id,
+            ]);
+        });
+
+        it("Timeline recovers after `/context` request to generate new timeline fails", async () => {
+            // `/context` request for `refreshLiveTimeline()` -> `getEventTimeline()`
+            // to construct a new timeline from.
+            httpBackend!
+                .when("GET", contextUrl)
+                .check(() => {
+                    // The timeline should be cleared at this point in the refresh
+                    expect(room.timeline.length).toEqual(0);
+                })
+                .respond(
+                    500,
+                    new MatrixError({
+                        errcode: "TEST_FAKE_ERROR",
+                        error:
+                            "We purposely intercepted this /context request to make it fail " +
+                            "in order to test whether the refresh timeline code is resilient",
+                    }),
+                );
+
+            // Refresh the timeline and expect it to fail
+            const settledFailedRefreshPromises = await Promise.allSettled([
+                room.refreshLiveTimeline(),
+                httpBackend!.flushAllExpected(),
+            ]);
+            // We only expect `TEST_FAKE_ERROR` here. Anything else is
+            // unexpected and should fail the test.
+            if (settledFailedRefreshPromises[0].status === "fulfilled") {
+                throw new Error("Expected the /context request to fail with a 500");
+            } else if (settledFailedRefreshPromises[0].reason.errcode !== "TEST_FAKE_ERROR") {
+                throw settledFailedRefreshPromises[0].reason;
+            }
+
+            // The timeline will be empty after we refresh the timeline and fail
+            // to construct a new timeline.
+            expect(room.timeline.length).toEqual(0);
+
+            // `/messages` request for `refreshLiveTimeline()` ->
+            // `getLatestTimeline()` to construct a new timeline from.
+            httpBackend!.when("GET", `/rooms/${encodeURIComponent(roomId)}/messages`).respond(200, function () {
+                return {
+                    chunk: [
+                        {
+                            // The latest message in the room
+                            event_id: initialSyncEventData[2].event_id,
+                        },
+                    ],
+                };
+            });
+            // `/context` request for `refreshLiveTimeline()` ->
+            // `getLatestTimeline()` -> `getEventTimeline()` to construct a new
+            // timeline from.
+            httpBackend!.when("GET", contextUrl).respond(200, function () {
+                // The timeline should be cleared at this point in the refresh
+                expect(room.timeline.length).toEqual(0);
+
+                return contextResponse;
+            });
+
+            // Refresh the timeline again but this time it should pass
+            await Promise.all([room.refreshLiveTimeline(), httpBackend!.flushAllExpected()]);
+
+            // Make sure sync pagination still works by seeing a new message show up
+            // after refreshing the timeline.
+            const afterRefreshEventData = [utils.mkMessage({ user: userId, room: roomId })];
+            setNextSyncData(afterRefreshEventData);
+            httpBackend!.when("GET", "/sync").respond(200, function () {
+                return NEXT_SYNC_DATA;
+            });
+            await Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 1)]);
+
+            // Make sure the message are visible
+            const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
+            const resultantEventIdsInTimeline = resultantEventsInTimeline.map((event) => event.getId());
+            expect(resultantEventIdsInTimeline).toEqual([
+                initialSyncEventData[0].event_id,
+                initialSyncEventData[1].event_id,
+                initialSyncEventData[2].event_id,
+                afterRefreshEventData[0].event_id,
+            ]);
+        });
+    });
+});

spec/integ/megolm-backup.spec.ts

@@ -23,22 +23,23 @@ import { TestClient } from "../TestClient";
 import { IEvent } from "../../src";
 import { MatrixEvent, MatrixEventEvent } from "../../src/models/event";
 
-const ROOM_ID = '!ROOM:ID';
+const ROOM_ID = "!ROOM:ID";
 
-const SESSION_ID = 'o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc';
+const SESSION_ID = "o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc";
 
 const ENCRYPTED_EVENT: Partial<IEvent> = {
-    type: 'm.room.encrypted',
+    type: "m.room.encrypted",
     content: {
-        algorithm: 'm.megolm.v1.aes-sha2',
-        sender_key: 'SENDER_CURVE25519',
+        algorithm: "m.megolm.v1.aes-sha2",
+        sender_key: "SENDER_CURVE25519",
         session_id: SESSION_ID,
-        ciphertext: 'AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N'
-            + 'CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl'
-            + 'mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs',
+        ciphertext:
+            "AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N" +
+            "CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl" +
+            "mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs",
     },
-    room_id: '!ROOM:ID',
-    event_id: '$event1',
+    room_id: "!ROOM:ID",
+    event_id: "$event1",
     origin_server_ts: 1507753886000,
 };
 
@@ -47,19 +48,20 @@ const CURVE25519_KEY_BACKUP_DATA: IKeyBackupSession = {
     forwarded_count: 0,
     is_verified: false,
     session_data: {
-        ciphertext: '2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw'
-            + '6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ'
-            + 'Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9'
-            + 'SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy'
-            + 'Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF'
-            + 'ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV'
-            + '4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv'
-            + 'C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe'
-            + 'Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf'
-            + 'QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy'
-            + 'iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg',
-        mac: '5lxYBHQU80M',
-        ephemeral: '/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14',
+        ciphertext:
+            "2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw" +
+            "6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ" +
+            "Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9" +
+            "SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy" +
+            "Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF" +
+            "ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV" +
+            "4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv" +
+            "C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe" +
+            "Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf" +
+            "QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy" +
+            "iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg",
+        mac: "5lxYBHQU80M",
+        ephemeral: "/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14",
     },
 };
 
@@ -82,84 +84,87 @@ function createOlmSession(olmAccount: Olm.Account, recipientTestClient: TestClie
         const otk = keys[otkId];
 
         const session = new global.Olm.Session();
-        session.create_outbound(
-            olmAccount, recipientTestClient.getDeviceKey(), otk.key,
-        );
+        session.create_outbound(olmAccount, recipientTestClient.getDeviceKey(), otk.key);
         return session;
     });
 }
 
-describe("megolm key backups", function() {
+describe("megolm key backups", function () {
     if (!global.Olm) {
-        logger.warn('not running megolm tests: Olm not present');
+        logger.warn("not running megolm tests: Olm not present");
         return;
     }
     const Olm = global.Olm;
-
-    let testOlmAccount: Account;
+    let testOlmAccount: Olm.Account;
     let aliceTestClient: TestClient;
 
-    beforeAll(function() {
+    const setupTestClient = (): [Account, TestClient] => {
+        const aliceTestClient = new TestClient("@alice:localhost", "xzcvb", "akjgkrgjs");
+        const testOlmAccount = new Olm.Account();
+        testOlmAccount!.create();
+
+        return [testOlmAccount, aliceTestClient];
+    };
+
+    beforeAll(function () {
         return Olm.init();
     });
 
-    beforeEach(async function() {
-        aliceTestClient = new TestClient(
-            "@alice:localhost", "xzcvb", "akjgkrgjs",
-        );
-        testOlmAccount = new Olm.Account();
-        testOlmAccount.create();
-        await aliceTestClient.client.initCrypto();
-        aliceTestClient.client.crypto.backupManager.backupInfo = CURVE25519_BACKUP_INFO;
+    beforeEach(async function () {
+        [testOlmAccount, aliceTestClient] = setupTestClient();
+        await aliceTestClient!.client.initCrypto();
+        aliceTestClient!.client.crypto!.backupManager.backupInfo = CURVE25519_BACKUP_INFO;
     });
 
-    afterEach(function() {
-        return aliceTestClient.stop();
+    afterEach(function () {
+        return aliceTestClient!.stop();
     });
 
-    it("Alice checks key backups when receiving a message she can't decrypt", function() {
+    it("Alice checks key backups when receiving a message she can't decrypt", function () {
         const syncResponse = {
             next_batch: 1,
             rooms: {
-                join: {},
-            },
-        };
-        syncResponse.rooms.join[ROOM_ID] = {
-            timeline: {
-                events: [ENCRYPTED_EVENT],
+                join: {
+                    [ROOM_ID]: {
+                        timeline: {
+                            events: [ENCRYPTED_EVENT],
+                        },
+                    },
+                },
             },
         };
 
-        return aliceTestClient.start().then(() => {
-            return createOlmSession(testOlmAccount, aliceTestClient);
-        }).then(() => {
-            const privkey = decodeRecoveryKey(RECOVERY_KEY);
-            return aliceTestClient.client.crypto.storeSessionBackupPrivateKey(privkey);
-        }).then(() => {
-            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
-            aliceTestClient.expectKeyBackupQuery(
-                ROOM_ID,
-                SESSION_ID,
-                200,
-                CURVE25519_KEY_BACKUP_DATA,
-            );
-            return aliceTestClient.httpBackend.flushAllExpected();
-        }).then(function(): Promise<MatrixEvent> {
-            const room = aliceTestClient.client.getRoom(ROOM_ID);
-            const event = room.getLiveTimeline().getEvents()[0];
+        return aliceTestClient!
+            .start()
+            .then(() => {
+                return createOlmSession(testOlmAccount, aliceTestClient);
+            })
+            .then(() => {
+                const privkey = decodeRecoveryKey(RECOVERY_KEY);
+                return aliceTestClient!.client!.crypto!.storeSessionBackupPrivateKey(privkey);
+            })
+            .then(() => {
+                aliceTestClient!.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+                aliceTestClient!.expectKeyBackupQuery(ROOM_ID, SESSION_ID, 200, CURVE25519_KEY_BACKUP_DATA);
+                return aliceTestClient!.httpBackend.flushAllExpected();
+            })
+            .then(function (): Promise<MatrixEvent> {
+                const room = aliceTestClient!.client.getRoom(ROOM_ID)!;
+                const event = room.getLiveTimeline().getEvents()[0];
 
-            if (event.getContent()) {
-                return Promise.resolve(event);
-            }
+                if (event.getContent()) {
+                    return Promise.resolve(event);
+                }
 
-            return new Promise((resolve, reject) => {
-                event.once(MatrixEventEvent.Decrypted, (ev) => {
-                    logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
-                    resolve(ev);
+                return new Promise((resolve, reject) => {
+                    event.once(MatrixEventEvent.Decrypted, (ev) => {
+                        logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
+                        resolve(ev);
+                    });
                 });
+            })
+            .then((event) => {
+                expect(event.getContent()).toEqual("testytest");
             });
-        }).then((event) => {
-            expect(event.getContent()).toEqual('testytest');
-        });
     });
 });

spec/integ/olm-encryption-spec.ts

@@ -0,0 +1,692 @@
+/*
+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 { logger } from "../../src/logger";
+import * as testUtils from "../test-utils/test-utils";
+import { TestClient } from "../TestClient";
+import { CRYPTO_ENABLED, IClaimKeysRequest, IQueryKeysRequest, IUploadKeysRequest } from "../../src/client";
+import { ClientEvent, IContent, ISendEventResponse, MatrixClient, MatrixEvent } from "../../src/matrix";
+import { DeviceInfo } from "../../src/crypto/deviceinfo";
+import { IDeviceKeys, IOneTimeKey } from "../../src/crypto/dehydration";
+
+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: "m.text", body: "Hello, World" });
+}
+
+async function expectSendMessageRequest(httpBackend: TestClient["httpBackend"]): Promise<IContent> {
+    const path = "/send/m.room.encrypted/";
+    const prom = new Promise<IContent>((resolve) => {
+        httpBackend.when("PUT", path).respond(200, function (_path, content) {
+            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: "join",
+                                user: aliUserId,
+                            }),
+                            testUtils.mkMembership({
+                                mship: "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.initCrypto();
+
+        bobTestClient = new TestClient(bobUserId, bobDeviceId, bobAccessToken);
+        await bobTestClient.client.initCrypto();
+
+        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({});
+        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({});
+        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({});
+        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();
+    });
+});

spec/integ/rust-crypto.spec.ts

@@ -0,0 +1,90 @@
+/*
+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 "fake-indexeddb/auto";
+import { IDBFactory } from "fake-indexeddb";
+
+import { createClient } from "../../src";
+
+afterEach(() => {
+    // reset fake-indexeddb after each test, to make sure we don't leak connections
+    // cf https://github.com/dumbmatter/fakeIndexedDB#wipingresetting-the-indexeddb-for-a-fresh-state
+    // eslint-disable-next-line no-global-assign
+    indexedDB = new IDBFactory();
+});
+
+describe("MatrixClient.initRustCrypto", () => {
+    it("should raise if userId or deviceId is unknown", async () => {
+        const unknownUserClient = createClient({
+            baseUrl: "http://test.server",
+            deviceId: "aliceDevice",
+        });
+        await expect(() => unknownUserClient.initRustCrypto()).rejects.toThrow("unknown userId");
+
+        const unknownDeviceClient = createClient({
+            baseUrl: "http://test.server",
+            userId: "@alice:test",
+        });
+        await expect(() => unknownDeviceClient.initRustCrypto()).rejects.toThrow("unknown deviceId");
+    });
+
+    it("should create the indexed dbs", async () => {
+        const matrixClient = createClient({
+            baseUrl: "http://test.server",
+            userId: "@alice:localhost",
+            deviceId: "aliceDevice",
+        });
+
+        // No databases.
+        expect(await indexedDB.databases()).toHaveLength(0);
+
+        await matrixClient.initRustCrypto();
+
+        // should have two dbs now
+        const databaseNames = (await indexedDB.databases()).map((db) => db.name);
+        expect(databaseNames).toEqual(
+            expect.arrayContaining(["matrix-js-sdk::matrix-sdk-crypto", "matrix-js-sdk::matrix-sdk-crypto-meta"]),
+        );
+    });
+
+    it("should ignore a second call", async () => {
+        const matrixClient = createClient({
+            baseUrl: "http://test.server",
+            userId: "@alice:localhost",
+            deviceId: "aliceDevice",
+        });
+
+        await matrixClient.initRustCrypto();
+        await matrixClient.initRustCrypto();
+    });
+});
+
+describe("MatrixClient.clearStores", () => {
+    it("should clear the indexeddbs", async () => {
+        const matrixClient = createClient({
+            baseUrl: "http://test.server",
+            userId: "@alice:localhost",
+            deviceId: "aliceDevice",
+        });
+
+        await matrixClient.initRustCrypto();
+        expect(await indexedDB.databases()).toHaveLength(2);
+        await matrixClient.stopClient();
+
+        await matrixClient.clearStores();
+        expect(await indexedDB.databases()).toHaveLength(0);
+    });
+});

spec/olm-loader.ts

@@ -15,21 +15,13 @@ 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 { logger } from "../src/logger";
 
 // try to load the olm library.
 try {
-    global.Olm = require('@matrix-org/olm');
-    logger.log('loaded libolm');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    global.Olm = require("@matrix-org/olm");
+    logger.log("loaded libolm");
 } catch (e) {
     logger.warn("unable to run crypto tests: libolm not available");
 }
-
-// also try to set node crypto
-try {
-    const crypto = require('crypto');
-    utils.setCrypto(crypto);
-} catch (err) {
-    logger.log('nodejs was compiled without crypto support: some tests will fail');
-}

spec/setupTests.ts

@@ -0,0 +1,25 @@
+/*
+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 DOMException from "domexception";
+
+global.DOMException = DOMException;
+
+jest.mock("../src/http-api/utils", () => ({
+    ...jest.requireActual("../src/http-api/utils"),
+    // We mock timeoutSignal otherwise it causes tests to leave timers running
+    timeoutSignal: () => new AbortController().signal,
+}));

spec/slowReporter.js

@@ -0,0 +1,100 @@
+/*
+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.
+*/
+
+/* eslint-disable no-console */
+
+class JestSlowTestReporter {
+    constructor(globalConfig, options) {
+        this._globalConfig = globalConfig;
+        this._options = options;
+        this._slowTests = [];
+        this._slowTestSuites = [];
+    }
+
+    onRunComplete() {
+        const displayResult = (result, isTestSuite) => {
+            if (!isTestSuite) console.log();
+
+            result.sort((a, b) => b.duration - a.duration);
+            const rootPathRegex = new RegExp(`^${process.cwd()}`);
+            const slowestTests = result.slice(0, this._options.numTests || 10);
+            const slowTestTime = this._slowTestTime(slowestTests);
+            const allTestTime = this._allTestTime(result);
+            const percentTime = (slowTestTime / allTestTime) * 100;
+
+            if (isTestSuite) {
+                console.log(
+                    `Top ${slowestTests.length} slowest test suites (${slowTestTime / 1000} seconds,` +
+                        ` ${percentTime.toFixed(1)}% of total time):`,
+                );
+            } else {
+                console.log(
+                    `Top ${slowestTests.length} slowest tests (${slowTestTime / 1000} seconds,` +
+                        ` ${percentTime.toFixed(1)}% of total time):`,
+                );
+            }
+
+            for (let i = 0; i < slowestTests.length; i++) {
+                const duration = slowestTests[i].duration;
+                const filePath = slowestTests[i].filePath.replace(rootPathRegex, ".");
+
+                if (isTestSuite) {
+                    console.log(`  ${duration / 1000} seconds ${filePath}`);
+                } else {
+                    const fullName = slowestTests[i].fullName;
+                    console.log(`  ${fullName}`);
+                    console.log(`    ${duration / 1000} seconds ${filePath}`);
+                }
+            }
+            console.log();
+        };
+
+        displayResult(this._slowTests);
+        displayResult(this._slowTestSuites, true);
+    }
+
+    onTestResult(test, testResult) {
+        this._slowTestSuites.push({
+            duration: testResult.perfStats.runtime,
+            filePath: testResult.testFilePath,
+        });
+        for (let i = 0; i < testResult.testResults.length; i++) {
+            this._slowTests.push({
+                duration: testResult.testResults[i].duration,
+                fullName: testResult.testResults[i].fullName,
+                filePath: testResult.testFilePath,
+            });
+        }
+    }
+
+    _slowTestTime(slowestTests) {
+        let slowTestTime = 0;
+        for (let i = 0; i < slowestTests.length; i++) {
+            slowTestTime += slowestTests[i].duration;
+        }
+        return slowTestTime;
+    }
+
+    _allTestTime(result) {
+        let allTestTime = 0;
+        for (let i = 0; i < result.length; i++) {
+            allTestTime += result[i].duration;
+        }
+        return allTestTime;
+    }
+}
+
+module.exports = JestSlowTestReporter;

spec/test-utils/beacon.ts

@@ -17,10 +17,7 @@ limitations under the License.
 import { MatrixEvent } from "../../src";
 import { M_BEACON, M_BEACON_INFO } from "../../src/@types/beacon";
 import { LocationAssetType } from "../../src/@types/location";
-import {
-    makeBeaconContent,
-    makeBeaconInfoContent,
-} from "../../src/content-helpers";
+import { makeBeaconContent, makeBeaconInfoContent } from "../../src/content-helpers";
 
 type InfoContentProps = {
     timeout: number;
@@ -44,13 +41,7 @@ export const makeBeaconInfoEvent = (
     contentProps: Partial<InfoContentProps> = {},
     eventId?: string,
 ): MatrixEvent => {
-    const {
-        timeout,
-        isLive,
-        description,
-        assetType,
-        timestamp,
-    } = {
+    const { timeout, isLive, description, assetType, timestamp } = {
         ...DEFAULT_INFO_CONTENT_PROPS,
         ...contentProps,
     };
@@ -77,9 +68,9 @@ type ContentProps = {
     description?: string;
 };
 const DEFAULT_CONTENT_PROPS: ContentProps = {
-    uri: 'geo:-36.24484561954707,175.46884959563613;u=10',
+    uri: "geo:-36.24484561954707,175.46884959563613;u=10",
     timestamp: 123,
-    beaconInfoId: '$123',
+    beaconInfoId: "$123",
 };
 
 /**
@@ -87,10 +78,7 @@ const DEFAULT_CONTENT_PROPS: ContentProps = {
  * all required properties are mocked
  * override with contentProps
  */
-export const makeBeaconEvent = (
-    sender: string,
-    contentProps: Partial<ContentProps> = {},
-): MatrixEvent => {
+export const makeBeaconEvent = (sender: string, contentProps: Partial<ContentProps> = {}): MatrixEvent => {
     const { uri, timestamp, beaconInfoId, description } = {
         ...DEFAULT_CONTENT_PROPS,
         ...contentProps,
@@ -107,10 +95,13 @@ export const makeBeaconEvent = (
  * Create a mock geolocation position
  * defaults all required properties
  */
-export const makeGeolocationPosition = (
-    { timestamp, coords }:
-        { timestamp?: number, coords: Partial<GeolocationCoordinates> },
-): GeolocationPosition => ({
+export const makeGeolocationPosition = ({
+    timestamp,
+    coords,
+}: {
+    timestamp?: number;
+    coords: Partial<GeolocationCoordinates>;
+}): GeolocationPosition => ({
     timestamp: timestamp ?? 1647256791840,
     coords: {
         accuracy: 1,

spec/test-utils/client.ts

@@ -0,0 +1,93 @@
+/*
+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 { MethodLikeKeys, mocked, MockedObject } from "jest-mock";
+
+import { ClientEventHandlerMap, EmittedEvents, MatrixClient } from "../../src/client";
+import { TypedEventEmitter } from "../../src/models/typed-event-emitter";
+import { User } from "../../src/models/user";
+
+/**
+ * Mock client with real event emitter
+ * useful for testing code that listens
+ * to MatrixClient events
+ */
+export class MockClientWithEventEmitter extends TypedEventEmitter<EmittedEvents, ClientEventHandlerMap> {
+    constructor(mockProperties: Partial<Record<MethodLikeKeys<MatrixClient>, unknown>> = {}) {
+        super();
+        Object.assign(this, mockProperties);
+    }
+}
+
+/**
+ * - make a mock client
+ * - cast the type to mocked(MatrixClient)
+ * - spy on MatrixClientPeg.get to return the mock
+ * eg
+ * ```
+ * const mockClient = getMockClientWithEventEmitter({
+        getUserId: jest.fn().mockReturnValue(aliceId),
+    });
+ * ```
+ */
+export const getMockClientWithEventEmitter = (
+    mockProperties: Partial<Record<MethodLikeKeys<MatrixClient>, unknown>>,
+): MockedObject<MatrixClient> => {
+    const mock = mocked(new MockClientWithEventEmitter(mockProperties) as unknown as MatrixClient);
+    return mock;
+};
+
+/**
+ * Returns basic mocked client methods related to the current user
+ * ```
+ * const mockClient = getMockClientWithEventEmitter({
+        ...mockClientMethodsUser('@mytestuser:domain'),
+    });
+ * ```
+ */
+export const mockClientMethodsUser = (userId = "@alice:domain") => ({
+    getUserId: jest.fn().mockReturnValue(userId),
+    getUser: jest.fn().mockReturnValue(new User(userId)),
+    isGuest: jest.fn().mockReturnValue(false),
+    mxcUrlToHttp: jest.fn().mockReturnValue("mock-mxcUrlToHttp"),
+    credentials: { userId },
+    getThreePids: jest.fn().mockResolvedValue({ threepids: [] }),
+    getAccessToken: jest.fn(),
+});
+
+/**
+ * Returns basic mocked client methods related to rendering events
+ * ```
+ * const mockClient = getMockClientWithEventEmitter({
+        ...mockClientMethodsUser('@mytestuser:domain'),
+    });
+ * ```
+ */
+export const mockClientMethodsEvents = () => ({
+    decryptEventIfNeeded: jest.fn(),
+    getPushActionsForEvent: jest.fn(),
+});
+
+/**
+ * Returns basic mocked client methods related to server support
+ */
+export const mockClientMethodsServer = (): Partial<Record<MethodLikeKeys<MatrixClient>, unknown>> => ({
+    doesServerSupportSeparateAddAndBind: jest.fn(),
+    getIdentityServerUrl: jest.fn(),
+    getHomeserverUrl: jest.fn(),
+    getCapabilities: jest.fn().mockReturnValue({}),
+    doesServerSupportUnstableFeature: jest.fn().mockResolvedValue(false),
+});

spec/test-utils/emitter.ts

@@ -24,5 +24,5 @@ limitations under the License.
  * expect(beaconLivenessEmits.length).toBe(1);
  * ```
  */
-export const filterEmitCallsByEventType = (eventType: string, spy: jest.SpyInstance<any, unknown[]>) =>
+export const filterEmitCallsByEventType = (eventType: string, spy: jest.SpyInstance<any, any[]>) =>
     spy.mock.calls.filter((args) => args[0] === eventType);

spec/test-utils/flushPromises.ts

@@ -0,0 +1,28 @@
+/*
+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.
+*/
+
+// Jest now uses @sinonjs/fake-timers which exposes tickAsync() and a number of
+// other async methods which break the event loop, letting scheduled promise
+// callbacks run. Unfortunately, Jest doesn't expose these, so we have to do
+// it manually (this is what sinon does under the hood). We do both in a loop
+// until the thing we expect happens: hopefully this is the least flakey way
+// and avoids assuming anything about the app's behaviour.
+const realSetTimeout = setTimeout;
+export function flushPromises() {
+    return new Promise((r) => {
+        realSetTimeout(r, 1);
+    });
+}

spec/test-utils/test-utils.ts

@@ -2,20 +2,20 @@
 import EventEmitter from "events";
 
 // load olm before the sdk if possible
-import '../olm-loader';
+import "../olm-loader";
 
-import { logger } from '../../src/logger';
-import { IContent, IEvent, IUnsigned, MatrixEvent, MatrixEventEvent } from "../../src/models/event";
-import { ClientEvent, EventType, MatrixClient, MsgType } from "../../src";
+import { logger } from "../../src/logger";
+import { IContent, IEvent, IEventRelation, IUnsigned, MatrixEvent, MatrixEventEvent } from "../../src/models/event";
+import { ClientEvent, EventType, IPusher, MatrixClient, MsgType } from "../../src";
 import { SyncState } from "../../src/sync";
 import { eventMapperFor } from "../../src/event-mapper";
 
 /**
  * Return a promise that is resolved when the client next emits a
  * SYNCING event.
- * @param {Object} client The client
- * @param {Number=} count Number of syncs to wait for (default 1)
- * @return {Promise} Resolves once the client has emitted a SYNCING event
+ * @param client - The client
+ * @param count - Number of syncs to wait for (default 1)
+ * @returns Promise which resolves once the client has emitted a SYNCING event
  */
 export function syncPromise(client: MatrixClient, count = 1): Promise<void> {
     if (count <= 0) {
@@ -41,20 +41,21 @@ export function syncPromise(client: MatrixClient, count = 1): Promise<void> {
 
 /**
  * Create a spy for an object and automatically spy its methods.
- * @param {*} constr The class constructor (used with 'new')
- * @param {string} name The name of the class
- * @return {Object} An instantiated object with spied methods/properties.
+ * @param constr - The class constructor (used with 'new')
+ * @param name - The name of the class
+ * @returns An instantiated object with spied methods/properties.
  */
-export function mock<T>(constr: { new(...args: any[]): T }, name: string): T {
+export function mock<T>(constr: { new (...args: any[]): T }, name: string): T {
     // Based on http://eclipsesource.com/blogs/2014/03/27/mocks-in-jasmine-tests/
     const HelperConstr = new Function(); // jshint ignore:line
     HelperConstr.prototype = constr.prototype;
     // @ts-ignore
     const result = new HelperConstr();
-    result.toString = function() {
+    result.toString = function () {
         return "mock" + (name ? " of " + name : "");
     };
-    for (const key of Object.getOwnPropertyNames(constr.prototype)) { // eslint-disable-line guard-for-in
+    for (const key of Object.getOwnPropertyNames(constr.prototype)) {
+        // eslint-disable-line guard-for-in
         try {
             if (constr.prototype[key] instanceof Function) {
                 result[key] = jest.fn();
@@ -70,31 +71,33 @@ export function mock<T>(constr: { new(...args: any[]): T }, name: string): T {
 
 interface IEventOpts {
     type: EventType | string;
-    room: string;
+    room?: string;
     sender?: string;
     skey?: string;
     content: IContent;
+    prev_content?: IContent;
     user?: string;
     unsigned?: IUnsigned;
     redacts?: string;
+    ts?: number;
 }
 
 let testEventIndex = 1; // counter for events, easier for comparison of randomly generated events
 /**
  * Create an Event.
- * @param {Object} opts Values for the event.
- * @param {string} opts.type The event.type
- * @param {string} opts.room The event.room_id
- * @param {string} opts.sender The event.sender
- * @param {string} opts.skey Optional. The state key (auto inserts empty string)
- * @param {Object} opts.content The event.content
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @param {MatrixClient} client If passed along with opts.event=true will be used to set up re-emitters.
- * @return {Object} a JSON object representing this event.
+ * @param opts - Values for the event.
+ * @param opts.type - The event.type
+ * @param opts.room - The event.room_id
+ * @param opts.sender - The event.sender
+ * @param opts.skey - Optional. The state key (auto inserts empty string)
+ * @param opts.content - The event.content
+ * @param opts.event - True to make a MatrixEvent.
+ * @param client - If passed along with opts.event=true will be used to set up re-emitters.
+ * @returns a JSON object representing this event.
  */
 export function mkEvent(opts: IEventOpts & { event: true }, client?: MatrixClient): MatrixEvent;
-export function mkEvent(opts: IEventOpts & { event?: false }, client?: MatrixClient): object;
-export function mkEvent(opts: IEventOpts & { event?: boolean }, client?: MatrixClient): object | MatrixEvent {
+export function mkEvent(opts: IEventOpts & { event?: false }, client?: MatrixClient): Partial<IEvent>;
+export function mkEvent(opts: IEventOpts & { event?: boolean }, client?: MatrixClient): Partial<IEvent> | MatrixEvent {
     if (!opts.type || !opts.content) {
         throw new Error("Missing .type or .content =>" + JSON.stringify(opts));
     }
@@ -103,22 +106,26 @@ export function mkEvent(opts: IEventOpts & { event?: boolean }, client?: MatrixC
         room_id: opts.room,
         sender: opts.sender || opts.user, // opts.user for backwards-compat
         content: opts.content,
+        prev_content: opts.prev_content,
         unsigned: opts.unsigned || {},
         event_id: "$" + testEventIndex++ + "-" + Math.random() + "-" + Math.random(),
         txn_id: "~" + Math.random(),
         redacts: opts.redacts,
+        origin_server_ts: opts.ts ?? 0,
     };
     if (opts.skey !== undefined) {
         event.state_key = opts.skey;
-    } else if ([
-        EventType.RoomName,
-        EventType.RoomTopic,
-        EventType.RoomCreate,
-        EventType.RoomJoinRules,
-        EventType.RoomPowerLevels,
-        EventType.RoomTopic,
-        "com.example.state",
-    ].includes(opts.type)) {
+    } else if (
+        [
+            EventType.RoomName,
+            EventType.RoomTopic,
+            EventType.RoomCreate,
+            EventType.RoomJoinRules,
+            EventType.RoomPowerLevels,
+            EventType.RoomTopic,
+            "com.example.state",
+        ].includes(opts.type)
+    ) {
         event.state_key = "";
     }
 
@@ -129,24 +136,39 @@ export function mkEvent(opts: IEventOpts & { event?: boolean }, client?: MatrixC
     return opts.event ? new MatrixEvent(event) : event;
 }
 
+type GeneratedMetadata = {
+    event_id: string;
+    txn_id: string;
+    origin_server_ts: number;
+};
+
+export function mkEventCustom<T>(base: T): T & GeneratedMetadata {
+    return {
+        event_id: "$" + testEventIndex++ + "-" + Math.random() + "-" + Math.random(),
+        txn_id: "~" + Math.random(),
+        origin_server_ts: Date.now(),
+        ...base,
+    };
+}
+
 interface IPresenceOpts {
     user?: string;
     sender?: string;
-    url: string;
-    name: string;
-    ago: number;
+    url?: string;
+    name?: string;
+    ago?: number;
     presence?: string;
     event?: boolean;
 }
 
 /**
  * Create an m.presence event.
- * @param {Object} opts Values for the presence.
- * @return {Object|MatrixEvent} The event
+ * @param opts - Values for the presence.
+ * @returns The event
  */
 export function mkPresence(opts: IPresenceOpts & { event: true }): MatrixEvent;
-export function mkPresence(opts: IPresenceOpts & { event?: false }): object;
-export function mkPresence(opts: IPresenceOpts & { event?: boolean }): object | MatrixEvent {
+export function mkPresence(opts: IPresenceOpts & { event?: false }): Partial<IEvent>;
+export function mkPresence(opts: IPresenceOpts & { event?: boolean }): Partial<IEvent> | MatrixEvent {
     const event = {
         event_id: "$" + Math.random() + "-" + Math.random(),
         type: "m.presence",
@@ -162,7 +184,7 @@ export function mkPresence(opts: IPresenceOpts & { event?: boolean }): object |
 }
 
 interface IMembershipOpts {
-    room: string;
+    room?: string;
     mship: string;
     sender?: string;
     user?: string;
@@ -174,20 +196,20 @@ interface IMembershipOpts {
 
 /**
  * Create an m.room.member event.
- * @param {Object} opts Values for the membership.
- * @param {string} opts.room The room ID for the event.
- * @param {string} opts.mship The content.membership for the event.
- * @param {string} opts.sender The sender user ID for the event.
- * @param {string} opts.skey The target user ID for the event if applicable
+ * @param opts - Values for the membership.
+ * @param opts.room - The room ID for the event.
+ * @param opts.mship - The content.membership for the event.
+ * @param opts.sender - The sender user ID for the event.
+ * @param opts.skey - The target user ID for the event if applicable
  * e.g. for invites/bans.
- * @param {string} opts.name The content.displayname for the event.
- * @param {string} opts.url The content.avatar_url for the event.
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @return {Object|MatrixEvent} The event
+ * @param opts.name - The content.displayname for the event.
+ * @param opts.url - The content.avatar_url for the event.
+ * @param opts.event - True to make a MatrixEvent.
+ * @returns The event
  */
 export function mkMembership(opts: IMembershipOpts & { event: true }): MatrixEvent;
-export function mkMembership(opts: IMembershipOpts & { event?: false }): object;
-export function mkMembership(opts: IMembershipOpts & { event?: boolean }): object | MatrixEvent {
+export function mkMembership(opts: IMembershipOpts & { event?: false }): Partial<IEvent>;
+export function mkMembership(opts: IMembershipOpts & { event?: boolean }): Partial<IEvent> | MatrixEvent {
     const eventOpts: IEventOpts = {
         ...opts,
         type: EventType.RoomMember,
@@ -208,26 +230,43 @@ export function mkMembership(opts: IMembershipOpts & { event?: boolean }): objec
     return mkEvent(eventOpts);
 }
 
-interface IMessageOpts {
-    room: string;
+export function mkMembershipCustom<T>(
+    base: T & { membership: string; sender: string; content?: IContent },
+): T & { type: EventType; sender: string; state_key: string; content: IContent } & GeneratedMetadata {
+    const content = base.content || {};
+    return mkEventCustom({
+        ...base,
+        content: { ...content, membership: base.membership },
+        type: EventType.RoomMember,
+        state_key: base.sender,
+    });
+}
+
+export interface IMessageOpts {
+    room?: string;
     user: string;
     msg?: string;
     event?: boolean;
+    relatesTo?: IEventRelation;
+    ts?: number;
 }
 
 /**
  * Create an m.room.message event.
- * @param {Object} opts Values for the message
- * @param {string} opts.room The room ID for the event.
- * @param {string} opts.user The user ID for the event.
- * @param {string} opts.msg Optional. The content.body for the event.
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @param {MatrixClient} client If passed along with opts.event=true will be used to set up re-emitters.
- * @return {Object|MatrixEvent} The event
+ * @param opts - Values for the message
+ * @param opts.room - The room ID for the event.
+ * @param opts.user - The user ID for the event.
+ * @param opts.msg - Optional. The content.body for the event.
+ * @param opts.event - True to make a MatrixEvent.
+ * @param client - If passed along with opts.event=true will be used to set up re-emitters.
+ * @returns The event
  */
 export function mkMessage(opts: IMessageOpts & { event: true }, client?: MatrixClient): MatrixEvent;
-export function mkMessage(opts: IMessageOpts & { event?: false }, client?: MatrixClient): object;
-export function mkMessage(opts: IMessageOpts & { event?: boolean }, client?: MatrixClient): object | MatrixEvent {
+export function mkMessage(opts: IMessageOpts & { event?: false }, client?: MatrixClient): Partial<IEvent>;
+export function mkMessage(
+    opts: IMessageOpts & { event?: boolean },
+    client?: MatrixClient,
+): Partial<IEvent> | MatrixEvent {
     const eventOpts: IEventOpts = {
         ...opts,
         type: EventType.RoomMessage,
@@ -237,6 +276,10 @@ export function mkMessage(opts: IMessageOpts & { event?: boolean }, client?: Mat
         },
     };
 
+    if (opts.relatesTo) {
+        eventOpts.content["m.relates_to"] = opts.relatesTo;
+    }
+
     if (!eventOpts.content.body) {
         eventOpts.content.body = "Random->" + Math.random();
     }
@@ -250,21 +293,21 @@ interface IReplyMessageOpts extends IMessageOpts {
 /**
  * Create a reply message.
  *
- * @param {Object} opts Values for the message
- * @param {string} opts.room The room ID for the event.
- * @param {string} opts.user The user ID for the event.
- * @param {string} opts.msg Optional. The content.body for the event.
- * @param {MatrixEvent} opts.replyToMessage The replied message
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @param {MatrixClient} client If passed along with opts.event=true will be used to set up re-emitters.
- * @return {Object|MatrixEvent} The event
+ * @param opts - Values for the message
+ * @param opts.room - The room ID for the event.
+ * @param opts.user - The user ID for the event.
+ * @param opts.msg - Optional. The content.body for the event.
+ * @param opts.replyToMessage - The replied message
+ * @param opts.event - True to make a MatrixEvent.
+ * @param client - If passed along with opts.event=true will be used to set up re-emitters.
+ * @returns The event
  */
 export function mkReplyMessage(opts: IReplyMessageOpts & { event: true }, client?: MatrixClient): MatrixEvent;
-export function mkReplyMessage(opts: IReplyMessageOpts & { event?: false }, client?: MatrixClient): object;
+export function mkReplyMessage(opts: IReplyMessageOpts & { event?: false }, client?: MatrixClient): Partial<IEvent>;
 export function mkReplyMessage(
     opts: IReplyMessageOpts & { event?: boolean },
     client?: MatrixClient,
-): object | MatrixEvent {
+): Partial<IEvent> | MatrixEvent {
     const eventOpts: IEventOpts = {
         ...opts,
         type: EventType.RoomMessage,
@@ -275,7 +318,7 @@ export function mkReplyMessage(
                 "rel_type": "m.in_reply_to",
                 "event_id": opts.replyToMessage.getId(),
                 "m.in_reply_to": {
-                    "event_id": opts.replyToMessage.getId(),
+                    event_id: opts.replyToMessage.getId()!,
                 },
             },
         },
@@ -289,10 +332,8 @@ export function mkReplyMessage(
 
 /**
  * A mock implementation of webstorage
- *
- * @constructor
  */
-export class MockStorageApi {
+export class MockStorageApi implements Storage {
     private data: Record<string, any> = {};
 
     public get length() {
@@ -314,30 +355,63 @@ export class MockStorageApi {
     public removeItem(k: string): void {
         delete this.data[k];
     }
+
+    public clear(): void {
+        this.data = {};
+    }
 }
 
 /**
  * If an event is being decrypted, wait for it to finish being decrypted.
  *
- * @param {MatrixEvent} event
- * @returns {Promise} promise which resolves (to `event`) when the event has been decrypted
+ * @returns promise which resolves (to `event`) when the event has been decrypted
  */
-export async function awaitDecryption(event: MatrixEvent): Promise<MatrixEvent> {
+export async function awaitDecryption(
+    event: MatrixEvent,
+    { waitOnDecryptionFailure = false } = {},
+): Promise<MatrixEvent> {
     // An event is not always decrypted ahead of time
     // getClearContent is a good signal to know whether an event has been decrypted
     // already
     if (event.getClearContent() !== null) {
-        return event;
+        if (waitOnDecryptionFailure && event.isDecryptionFailure()) {
+            logger.log(`${Date.now()} event ${event.getId()} got decryption error; waiting`);
+        } else {
+            return event;
+        }
     } else {
-        logger.log(`${Date.now()} event ${event.getId()} is being decrypted; waiting`);
-
-        return new Promise((resolve) => {
-            event.once(MatrixEventEvent.Decrypted, (ev) => {
-                logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
-                resolve(ev);
-            });
-        });
+        logger.log(`${Date.now()} event ${event.getId()} is not yet decrypted; waiting`);
     }
+
+    return new Promise((resolve) => {
+        event.once(MatrixEventEvent.Decrypted, (ev) => {
+            logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
+            resolve(ev);
+        });
+    });
 }
 
-export const emitPromise = (e: EventEmitter, k: string): Promise<any> => new Promise(r => e.once(k, r));
+export const emitPromise = (e: EventEmitter, k: string): Promise<any> => new Promise((r) => e.once(k, r));
+
+export const mkPusher = (extra: Partial<IPusher> = {}): IPusher => ({
+    app_display_name: "app",
+    app_id: "123",
+    data: {},
+    device_display_name: "name",
+    kind: "http",
+    lang: "en",
+    pushkey: "pushpush",
+    ...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 (global.Olm) {
+    CRYPTO_BACKENDS["libolm"] = (client: MatrixClient) => client.initCrypto();
+}

spec/test-utils/thread.ts

@@ -0,0 +1,143 @@
+/*
+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 { 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 } from "../../src/models/thread";
+import { mkMessage } from "./test-utils";
+
+export const makeThreadEvent = ({
+    rootEventId,
+    replyToEventId,
+    ...props
+}: any & {
+    rootEventId: string;
+    replyToEventId: string;
+    event?: boolean;
+}): MatrixEvent =>
+    mkMessage({
+        ...props,
+        relatesTo: {
+            event_id: rootEventId,
+            rel_type: "m.thread",
+            ["m.in_reply_to"]: {
+                event_id: replyToEventId,
+            },
+        },
+    });
+
+type MakeThreadEventsProps = {
+    roomId: Room["roomId"];
+    // root message user id
+    authorId: string;
+    // user ids of thread replies
+    // cycled through until thread length is fulfilled
+    participantUserIds: string[];
+    // number of messages in the thread, root message included
+    // optional, default 2
+    length?: number;
+    ts?: number;
+    // provide to set current_user_participated accurately
+    currentUserId?: string;
+};
+
+export const makeThreadEvents = ({
+    roomId,
+    authorId,
+    participantUserIds,
+    length = 2,
+    ts = 1,
+    currentUserId,
+}: MakeThreadEventsProps): { rootEvent: MatrixEvent; events: MatrixEvent[] } => {
+    const rootEvent = mkMessage({
+        user: authorId,
+        room: roomId,
+        msg: "root event message " + Math.random(),
+        ts,
+        event: true,
+    });
+
+    const rootEventId = rootEvent.getId();
+    const events = [rootEvent];
+
+    for (let i = 1; i < length; i++) {
+        const prevEvent = events[i - 1];
+        const replyToEventId = prevEvent.getId();
+        const user = participantUserIds[i % participantUserIds.length];
+        events.push(
+            makeThreadEvent({
+                user,
+                room: roomId,
+                event: true,
+                msg: `reply ${i} by ${user}`,
+                rootEventId,
+                replyToEventId,
+                // replies are 1ms after each other
+                ts: ts + i,
+            }),
+        );
+    }
+
+    rootEvent.setUnsigned({
+        "m.relations": {
+            [RelationType.Thread]: {
+                latest_event: events[events.length - 1],
+                count: length,
+                current_user_participated: [...participantUserIds, authorId].includes(currentUserId ?? ""),
+            },
+        },
+    });
+
+    return { rootEvent, events };
+};
+
+type MakeThreadProps = {
+    room: Room;
+    client: MatrixClient;
+    authorId: string;
+    participantUserIds: string[];
+    length?: number;
+    ts?: number;
+};
+
+export const mkThread = ({
+    room,
+    client,
+    authorId,
+    participantUserIds,
+    length = 2,
+    ts = 1,
+}: MakeThreadProps): { thread: Thread; rootEvent: MatrixEvent; events: MatrixEvent[] } => {
+    const { rootEvent, events } = makeThreadEvents({
+        roomId: room.roomId,
+        authorId,
+        participantUserIds,
+        length,
+        ts,
+        currentUserId: client.getUserId() ?? "",
+    });
+    expect(rootEvent).toBeTruthy();
+
+    for (const evt of events) {
+        room?.reEmitter.reEmit(evt, [MatrixEventEvent.BeforeRedaction]);
+    }
+
+    const thread = room.createThread(rootEvent.getId() ?? "", rootEvent, events, true);
+
+    return { thread, rootEvent, events };
+};

spec/test-utils/webrtc.ts

@@ -0,0 +1,602 @@
+/*
+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 {
+    ClientEvent,
+    ClientEventHandlerMap,
+    EventType,
+    GroupCall,
+    GroupCallIntent,
+    GroupCallType,
+    IContent,
+    ISendEventResponse,
+    MatrixClient,
+    MatrixEvent,
+    Room,
+    RoomMember,
+    RoomState,
+    RoomStateEvent,
+    RoomStateEventHandlerMap,
+} 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";
+
+export const DUMMY_SDP =
+    "v=0\r\n" +
+    "o=- 5022425983810148698 2 IN IP4 127.0.0.1\r\n" +
+    "s=-\r\nt=0 0\r\na=group:BUNDLE 0\r\n" +
+    "a=msid-semantic: WMS h3wAi7s8QpiQMH14WG3BnDbmlOqo9I5ezGZA\r\n" +
+    "m=audio 9 UDP/TLS/RTP/SAVPF 111 103 104 9 0 8 106 105 13 110 112 113 126\r\n" +
+    "c=IN IP4 0.0.0.0\r\na=rtcp:9 IN IP4 0.0.0.0\r\na=ice-ufrag:hLDR\r\n" +
+    "a=ice-pwd:bMGD9aOldHWiI+6nAq/IIlRw\r\n" +
+    "a=ice-options:trickle\r\n" +
+    "a=fingerprint:sha-256 E4:94:84:F9:4A:98:8A:56:F5:5F:FD:AF:72:B9:32:89:49:5C:4B:9A:" +
+    "4A:15:8E:41:8A:F3:69:E4:39:52:DC:D6\r\n" +
+    "a=setup:active\r\n" +
+    "a=mid:0\r\n" +
+    "a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n" +
+    "a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n" +
+    "a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r\n" +
+    "a=extmap:4 urn:ietf:params:rtp-hdrext:sdes:mid\r\n" +
+    "a=extmap:5 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id\r\n" +
+    "a=extmap:6 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id\r\n" +
+    "a=sendrecv\r\n" +
+    "a=msid:h3wAi7s8QpiQMH14WG3BnDbmlOqo9I5ezGZA 4357098f-3795-4131-bff4-9ba9c0348c49\r\n" +
+    "a=rtcp-mux\r\n" +
+    "a=rtpmap:111 opus/48000/2\r\n" +
+    "a=rtcp-fb:111 transport-cc\r\n" +
+    "a=fmtp:111 minptime=10;useinbandfec=1\r\n" +
+    "a=rtpmap:103 ISAC/16000\r\n" +
+    "a=rtpmap:104 ISAC/32000\r\n" +
+    "a=rtpmap:9 G722/8000\r\n" +
+    "a=rtpmap:0 PCMU/8000\r\n" +
+    "a=rtpmap:8 PCMA/8000\r\n" +
+    "a=rtpmap:106 CN/32000\r\n" +
+    "a=rtpmap:105 CN/16000\r\n" +
+    "a=rtpmap:13 CN/8000\r\n" +
+    "a=rtpmap:110 telephone-event/48000\r\n" +
+    "a=rtpmap:112 telephone-event/32000\r\n" +
+    "a=rtpmap:113 telephone-event/16000\r\n" +
+    "a=rtpmap:126 telephone-event/8000\r\n" +
+    "a=ssrc:3619738545 cname:2RWtmqhXLdoF4sOi\r\n";
+
+export const USERMEDIA_STREAM_ID = "mock_stream_from_media_handler";
+export const SCREENSHARE_STREAM_ID = "mock_screen_stream_from_media_handler";
+
+export const FAKE_ROOM_ID = "!fake:test.dummy";
+export const FAKE_CONF_ID = "fakegroupcallid";
+
+export const FAKE_USER_ID_1 = "@alice:test.dummy";
+export const FAKE_DEVICE_ID_1 = "@AAAAAA";
+export const FAKE_SESSION_ID_1 = "alice1";
+export const FAKE_USER_ID_2 = "@bob:test.dummy";
+export const FAKE_DEVICE_ID_2 = "@BBBBBB";
+export const FAKE_SESSION_ID_2 = "bob1";
+export const FAKE_USER_ID_3 = "@charlie:test.dummy";
+
+class MockMediaStreamAudioSourceNode {
+    public connect() {}
+}
+
+class MockAnalyser {
+    public getFloatFrequencyData() {
+        return 0.0;
+    }
+}
+
+export class MockAudioContext {
+    constructor() {}
+    public createAnalyser() {
+        return new MockAnalyser();
+    }
+    public createMediaStreamSource() {
+        return new MockMediaStreamAudioSourceNode();
+    }
+    public close() {}
+}
+
+export class MockRTCPeerConnection {
+    private static instances: MockRTCPeerConnection[] = [];
+
+    private negotiationNeededListener?: () => void;
+    public iceCandidateListener?: (e: RTCPeerConnectionIceEvent) => void;
+    public iceConnectionStateChangeListener?: () => void;
+    public onTrackListener?: (e: RTCTrackEvent) => void;
+    public needsNegotiation = false;
+    public readyToNegotiate: Promise<void>;
+    private onReadyToNegotiate?: () => void;
+    public localDescription: RTCSessionDescription;
+    public signalingState: RTCSignalingState = "stable";
+    public iceConnectionState: RTCIceConnectionState = "connected";
+    public transceivers: MockRTCRtpTransceiver[] = [];
+
+    public static triggerAllNegotiations(): void {
+        for (const inst of this.instances) {
+            inst.doNegotiation();
+        }
+    }
+
+    public static hasAnyPendingNegotiations(): boolean {
+        return this.instances.some((i) => i.needsNegotiation);
+    }
+
+    public static resetInstances() {
+        this.instances = [];
+    }
+
+    constructor() {
+        this.localDescription = {
+            sdp: DUMMY_SDP,
+            type: "offer",
+            toJSON: function () {},
+        };
+
+        this.readyToNegotiate = new Promise<void>((resolve) => {
+            this.onReadyToNegotiate = resolve;
+        });
+
+        MockRTCPeerConnection.instances.push(this);
+    }
+
+    public addEventListener(type: string, listener: () => void) {
+        if (type === "negotiationneeded") {
+            this.negotiationNeededListener = listener;
+        } else if (type == "icecandidate") {
+            this.iceCandidateListener = listener;
+        } else if (type === "iceconnectionstatechange") {
+            this.iceConnectionStateChangeListener = listener;
+        } else if (type == "track") {
+            this.onTrackListener = listener;
+        }
+    }
+    public createDataChannel(label: string, opts: RTCDataChannelInit) {
+        return { label, ...opts };
+    }
+    public createOffer() {
+        return Promise.resolve({
+            type: "offer",
+            sdp: DUMMY_SDP,
+        });
+    }
+    public createAnswer() {
+        return Promise.resolve({
+            type: "answer",
+            sdp: DUMMY_SDP,
+        });
+    }
+    public setRemoteDescription() {
+        return Promise.resolve();
+    }
+    public setLocalDescription() {
+        return Promise.resolve();
+    }
+    public close() {}
+    public getStats() {
+        return [];
+    }
+    public addTransceiver(track: MockMediaStreamTrack): MockRTCRtpTransceiver {
+        this.needsNegotiation = true;
+        if (this.onReadyToNegotiate) this.onReadyToNegotiate();
+
+        const newSender = new MockRTCRtpSender(track);
+        const newReceiver = new MockRTCRtpReceiver(track);
+
+        const newTransceiver = new MockRTCRtpTransceiver(this);
+        newTransceiver.sender = newSender as unknown as RTCRtpSender;
+        newTransceiver.receiver = newReceiver as unknown as RTCRtpReceiver;
+
+        this.transceivers.push(newTransceiver);
+
+        return newTransceiver;
+    }
+    public addTrack(track: MockMediaStreamTrack): MockRTCRtpSender {
+        return this.addTransceiver(track).sender as unknown as MockRTCRtpSender;
+    }
+
+    public removeTrack() {
+        this.needsNegotiation = true;
+        if (this.onReadyToNegotiate) this.onReadyToNegotiate();
+    }
+
+    public getTransceivers(): MockRTCRtpTransceiver[] {
+        return this.transceivers;
+    }
+    public getSenders(): MockRTCRtpSender[] {
+        return this.transceivers.map((t) => t.sender as unknown as MockRTCRtpSender);
+    }
+
+    public doNegotiation() {
+        if (this.needsNegotiation && this.negotiationNeededListener) {
+            this.needsNegotiation = false;
+            this.negotiationNeededListener();
+        }
+    }
+}
+
+export class MockRTCRtpSender {
+    constructor(public track: MockMediaStreamTrack) {}
+
+    public replaceTrack(track: MockMediaStreamTrack) {
+        this.track = track;
+    }
+}
+
+export class MockRTCRtpReceiver {
+    constructor(public track: MockMediaStreamTrack) {}
+}
+
+export class MockRTCRtpTransceiver {
+    constructor(private peerConn: MockRTCPeerConnection) {}
+
+    public sender?: RTCRtpSender;
+    public receiver?: RTCRtpReceiver;
+
+    public set direction(_: string) {
+        this.peerConn.needsNegotiation = true;
+    }
+
+    public setCodecPreferences = jest.fn<void, RTCRtpCodecCapability[]>();
+}
+
+export class MockMediaStreamTrack {
+    constructor(public readonly id: string, public readonly kind: "audio" | "video", public enabled = true) {}
+
+    public stop = jest.fn<void, []>();
+
+    public listeners: [string, (...args: any[]) => any][] = [];
+    public isStopped = false;
+    public settings?: MediaTrackSettings;
+
+    public getSettings(): MediaTrackSettings {
+        return this.settings!;
+    }
+
+    // XXX: Using EventTarget in jest doesn't seem to work, so we write our own
+    // implementation
+    public dispatchEvent(eventType: string) {
+        this.listeners.forEach(([t, c]) => {
+            if (t !== eventType) return;
+            c();
+        });
+    }
+    public addEventListener(eventType: string, callback: (...args: any[]) => any) {
+        this.listeners.push([eventType, callback]);
+    }
+    public removeEventListener(eventType: string, callback: (...args: any[]) => any) {
+        this.listeners.filter(([t, c]) => {
+            return t !== eventType || c !== callback;
+        });
+    }
+
+    public typed(): MediaStreamTrack {
+        return this as unknown as MediaStreamTrack;
+    }
+}
+
+// XXX: Using EventTarget in jest doesn't seem to work, so we write our own
+// implementation
+export class MockMediaStream {
+    constructor(public id: string, private tracks: MockMediaStreamTrack[] = []) {}
+
+    public listeners: [string, (...args: any[]) => any][] = [];
+    public isStopped = false;
+
+    public dispatchEvent(eventType: string) {
+        this.listeners.forEach(([t, c]) => {
+            if (t !== eventType) return;
+            c();
+        });
+    }
+    public getTracks() {
+        return this.tracks;
+    }
+    public getAudioTracks() {
+        return this.tracks.filter((track) => track.kind === "audio");
+    }
+    public getVideoTracks() {
+        return this.tracks.filter((track) => track.kind === "video");
+    }
+    public addEventListener(eventType: string, callback: (...args: any[]) => any) {
+        this.listeners.push([eventType, callback]);
+    }
+    public removeEventListener(eventType: string, callback: (...args: any[]) => any) {
+        this.listeners.filter(([t, c]) => {
+            return t !== eventType || c !== callback;
+        });
+    }
+    public addTrack(track: MockMediaStreamTrack) {
+        this.tracks.push(track);
+        this.dispatchEvent("addtrack");
+    }
+    public removeTrack(track: MockMediaStreamTrack) {
+        this.tracks.splice(this.tracks.indexOf(track), 1);
+    }
+
+    public clone(): MediaStream {
+        return new MockMediaStream(this.id + ".clone", this.tracks).typed();
+    }
+
+    public isCloneOf(stream: MediaStream) {
+        return this.id === stream.id + ".clone";
+    }
+
+    // syntactic sugar for typing
+    public typed(): MediaStream {
+        return this as unknown as MediaStream;
+    }
+}
+
+export class MockMediaDeviceInfo {
+    constructor(public kind: "audioinput" | "videoinput" | "audiooutput") {}
+
+    public typed(): MediaDeviceInfo {
+        return this as unknown as MediaDeviceInfo;
+    }
+}
+
+export class MockMediaHandler {
+    public userMediaStreams: MockMediaStream[] = [];
+    public screensharingStreams: MockMediaStream[] = [];
+
+    public getUserMediaStream(audio: boolean, video: boolean) {
+        const tracks: MockMediaStreamTrack[] = [];
+        if (audio) tracks.push(new MockMediaStreamTrack("usermedia_audio_track", "audio"));
+        if (video) tracks.push(new MockMediaStreamTrack("usermedia_video_track", "video"));
+
+        const stream = new MockMediaStream(USERMEDIA_STREAM_ID, tracks);
+        this.userMediaStreams.push(stream);
+        return stream;
+    }
+    public stopUserMediaStream(stream: MockMediaStream) {
+        stream.isStopped = true;
+    }
+    public getScreensharingStream = jest.fn((opts?: IScreensharingOpts) => {
+        const tracks = [new MockMediaStreamTrack("screenshare_video_track", "video")];
+        if (opts?.audio) tracks.push(new MockMediaStreamTrack("screenshare_audio_track", "audio"));
+
+        const stream = new MockMediaStream(SCREENSHARE_STREAM_ID, tracks);
+        this.screensharingStreams.push(stream);
+        return stream;
+    });
+    public stopScreensharingStream(stream: MockMediaStream) {
+        stream.isStopped = true;
+    }
+    public hasAudioDevice() {
+        return true;
+    }
+    public hasVideoDevice() {
+        return true;
+    }
+    public stopAllStreams() {}
+
+    public typed(): MediaHandler {
+        return this as unknown as MediaHandler;
+    }
+}
+
+export class MockMediaDevices {
+    public enumerateDevices = jest
+        .fn<Promise<MediaDeviceInfo[]>, []>()
+        .mockResolvedValue([
+            new MockMediaDeviceInfo("audioinput").typed(),
+            new MockMediaDeviceInfo("videoinput").typed(),
+        ]);
+
+    public getUserMedia = jest
+        .fn<Promise<MediaStream>, [MediaStreamConstraints]>()
+        .mockReturnValue(Promise.resolve(new MockMediaStream("local_stream").typed()));
+
+    public getDisplayMedia = jest
+        .fn<Promise<MediaStream>, [MediaStreamConstraints]>()
+        .mockReturnValue(Promise.resolve(new MockMediaStream("local_display_stream").typed()));
+
+    public typed(): MediaDevices {
+        return this as unknown as MediaDevices;
+    }
+}
+
+type EmittedEvents = CallEventHandlerEvent | CallEvent | ClientEvent | RoomStateEvent | GroupCallEventHandlerEvent;
+type EmittedEventMap = CallEventHandlerEventHandlerMap &
+    CallEventHandlerMap &
+    ClientEventHandlerMap &
+    RoomStateEventHandlerMap &
+    GroupCallEventHandlerMap;
+
+export class MockCallMatrixClient extends TypedEventEmitter<EmittedEvents, EmittedEventMap> {
+    public mediaHandler = new MockMediaHandler();
+
+    constructor(public userId: string, public deviceId: string, public sessionId: string) {
+        super();
+    }
+
+    public groupCallEventHandler = {
+        groupCalls: new Map<string, GroupCall>(),
+    };
+
+    public callEventHandler = {
+        calls: new Map<string, MatrixCall>(),
+    };
+
+    public sendStateEvent = jest.fn<
+        Promise<ISendEventResponse>,
+        [roomId: string, eventType: EventType, content: any, statekey: string]
+    >();
+    public sendToDevice = jest.fn<
+        Promise<{}>,
+        [
+            eventType: string,
+            contentMap: { [userId: string]: { [deviceId: string]: Record<string, any> } },
+            txnId?: string,
+        ]
+    >();
+
+    public getMediaHandler(): MediaHandler {
+        return this.mediaHandler.typed();
+    }
+
+    public getUserId(): string {
+        return this.userId;
+    }
+
+    public getDeviceId(): string {
+        return this.deviceId;
+    }
+    public getSessionId(): string {
+        return this.sessionId;
+    }
+
+    public getTurnServers = () => [];
+    public isFallbackICEServerAllowed = () => false;
+    public reEmitter = new ReEmitter(new TypedEventEmitter());
+    public getUseE2eForGroupCall = () => false;
+    public checkTurnServers = () => null;
+
+    public getSyncState = jest.fn<SyncState | null, []>().mockReturnValue(SyncState.Syncing);
+
+    public getRooms = jest.fn<Room[], []>().mockReturnValue([]);
+    public getRoom = jest.fn();
+
+    public supportsExperimentalThreads(): boolean {
+        return true;
+    }
+    public async decryptEventIfNeeded(): Promise<void> {}
+
+    public typed(): MatrixClient {
+        return this as unknown as MatrixClient;
+    }
+
+    public emitRoomState(event: MatrixEvent, state: RoomState): void {
+        this.emit(RoomStateEvent.Events, event, state, null);
+    }
+}
+
+export class MockMatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap> {
+    constructor(public roomId: string, public groupCallId?: string) {
+        super();
+    }
+
+    public state = CallState.Ringing;
+    public opponentUserId = FAKE_USER_ID_1;
+    public opponentDeviceId = FAKE_DEVICE_ID_1;
+    public opponentMember = { userId: this.opponentUserId };
+    public callId = "1";
+    public localUsermediaFeed = {
+        setAudioVideoMuted: jest.fn<void, [boolean, boolean]>(),
+        stream: new MockMediaStream("stream"),
+    };
+    public remoteUsermediaFeed?: CallFeed;
+    public remoteScreensharingFeed?: CallFeed;
+
+    public reject = jest.fn<void, []>();
+    public answerWithCallFeeds = jest.fn<void, [CallFeed[]]>();
+    public hangup = jest.fn<void, []>();
+
+    public sendMetadataUpdate = jest.fn<void, []>();
+
+    public getOpponentMember(): Partial<RoomMember> {
+        return this.opponentMember;
+    }
+
+    public getOpponentDeviceId(): string | undefined {
+        return this.opponentDeviceId;
+    }
+
+    public typed(): MatrixCall {
+        return this as unknown as MatrixCall;
+    }
+}
+
+export class MockCallFeed {
+    constructor(public userId: string, public deviceId: string | undefined, public stream: MockMediaStream) {}
+
+    public measureVolumeActivity(val: boolean) {}
+    public dispose() {}
+
+    public typed(): CallFeed {
+        return this as unknown as CallFeed;
+    }
+}
+
+export function installWebRTCMocks() {
+    global.navigator = {
+        mediaDevices: new MockMediaDevices().typed(),
+    } as unknown as Navigator;
+
+    global.window = {
+        // @ts-ignore Mock
+        RTCPeerConnection: MockRTCPeerConnection,
+        // @ts-ignore Mock
+        RTCSessionDescription: {},
+        // @ts-ignore Mock
+        RTCIceCandidate: {},
+        getUserMedia: () => new MockMediaStream("local_stream"),
+    };
+    // @ts-ignore Mock
+    global.document = {};
+
+    // @ts-ignore Mock
+    global.AudioContext = MockAudioContext;
+
+    // @ts-ignore Mock
+    global.RTCRtpReceiver = {
+        getCapabilities: jest.fn<RTCRtpCapabilities, [string]>().mockReturnValue({
+            codecs: [],
+            headerExtensions: [],
+        }),
+    };
+
+    // @ts-ignore Mock
+    global.RTCRtpSender = {
+        getCapabilities: jest.fn<RTCRtpCapabilities, [string]>().mockReturnValue({
+            codecs: [],
+            headerExtensions: [],
+        }),
+    };
+}
+
+export function makeMockGroupCallStateEvent(
+    roomId: string,
+    groupCallId: string,
+    content: IContent = {
+        "m.type": GroupCallType.Video,
+        "m.intent": GroupCallIntent.Prompt,
+    },
+): MatrixEvent {
+    return {
+        getType: jest.fn().mockReturnValue(EventType.GroupCallPrefix),
+        getRoomId: jest.fn().mockReturnValue(roomId),
+        getTs: jest.fn().mockReturnValue(0),
+        getContent: jest.fn().mockReturnValue(content),
+        getStateKey: jest.fn().mockReturnValue(groupCallId),
+    } as unknown as MatrixEvent;
+}
+
+export function makeMockGroupCallMemberStateEvent(roomId: string, groupCallId: string): MatrixEvent {
+    return {
+        getType: jest.fn().mockReturnValue(EventType.GroupCallMemberPrefix),
+        getRoomId: jest.fn().mockReturnValue(roomId),
+        getTs: jest.fn().mockReturnValue(0),
+        getContent: jest.fn().mockReturnValue({}),
+        getStateKey: jest.fn().mockReturnValue(groupCallId),
+    } as unknown as MatrixEvent;
+}

spec/unit/NamespacedValue.spec.ts

@@ -21,34 +21,37 @@ describe("NamespacedValue", () => {
         const ns = new NamespacedValue("stable", "unstable");
         expect(ns.name).toBe(ns.stable);
         expect(ns.altName).toBe(ns.unstable);
+        expect(ns.names).toEqual([ns.stable, ns.unstable]);
     });
 
     it("should return unstable if there is no stable", () => {
         const ns = new NamespacedValue(null, "unstable");
         expect(ns.name).toBe(ns.unstable);
         expect(ns.altName).toBeFalsy();
+        expect(ns.names).toEqual([ns.unstable]);
     });
 
     it("should have a falsey unstable if needed", () => {
-        const ns = new NamespacedValue("stable", null);
+        const ns = new NamespacedValue("stable");
         expect(ns.name).toBe(ns.stable);
         expect(ns.altName).toBeFalsy();
+        expect(ns.names).toEqual([ns.stable]);
     });
 
     it("should match against either stable or unstable", () => {
         const ns = new NamespacedValue("stable", "unstable");
         expect(ns.matches("no")).toBe(false);
-        expect(ns.matches(ns.stable)).toBe(true);
-        expect(ns.matches(ns.unstable)).toBe(true);
+        expect(ns.matches(ns.stable!)).toBe(true);
+        expect(ns.matches(ns.unstable!)).toBe(true);
     });
 
     it("should not permit falsey values for both parts", () => {
         try {
-            new UnstableValue(null, null);
+            new UnstableValue(null!, null!);
             // noinspection ExceptionCaughtLocallyJS
             throw new Error("Failed to fail");
         } catch (e) {
-            expect(e.message).toBe("One of stable or unstable values must be supplied");
+            expect((<Error>e).message).toBe("One of stable or unstable values must be supplied");
         }
     });
 });
@@ -58,21 +61,23 @@ describe("UnstableValue", () => {
         const ns = new UnstableValue("stable", "unstable");
         expect(ns.name).toBe(ns.unstable);
         expect(ns.altName).toBe(ns.stable);
+        expect(ns.names).toEqual([ns.unstable, ns.stable]);
     });
 
     it("should return unstable if there is no stable", () => {
-        const ns = new UnstableValue(null, "unstable");
+        const ns = new UnstableValue(null!, "unstable");
         expect(ns.name).toBe(ns.unstable);
         expect(ns.altName).toBeFalsy();
+        expect(ns.names).toEqual([ns.unstable]);
     });
 
     it("should not permit falsey unstable values", () => {
         try {
-            new UnstableValue("stable", null);
+            new UnstableValue("stable", null!);
             // noinspection ExceptionCaughtLocallyJS
             throw new Error("Failed to fail");
         } catch (e) {
-            expect(e.message).toBe("Unstable value must be supplied");
+            expect((<Error>e).message).toBe("Unstable value must be supplied");
         }
     });
 });

spec/unit/ReEmitter.spec.ts

@@ -27,16 +27,14 @@ class EventSource extends EventEmitter {
     }
 
     doAnError() {
-        this.emit('error');
+        this.emit("error");
     }
 }
 
-class EventTarget extends EventEmitter {
+class EventTarget extends EventEmitter {}
 
-}
-
-describe("ReEmitter", function() {
-    it("Re-Emits events with the same args", function() {
+describe("ReEmitter", function () {
+    it("Re-Emits events with the same args", function () {
         const src = new EventSource();
         const tgt = new EventTarget();
 
@@ -53,18 +51,18 @@ describe("ReEmitter", function() {
         expect(handler).toHaveBeenCalledWith("foo", "bar", src);
     });
 
-    it("Doesn't throw if no handler for 'error' event", function() {
+    it("Doesn't throw if no handler for 'error' event", function () {
         const src = new EventSource();
         const tgt = new EventTarget();
 
         const reEmitter = new ReEmitter(tgt);
-        reEmitter.reEmit(src, ['error']);
+        reEmitter.reEmit(src, ["error"]);
 
         // without the workaround in ReEmitter, this would throw
         src.doAnError();
 
         const handler = jest.fn();
-        tgt.on('error', handler);
+        tgt.on("error", handler);
 
         src.doAnError();
 

spec/unit/ToDeviceMessageQueue.spec.ts

@@ -0,0 +1,106 @@
+import { ConnectionError } from "../../src/http-api/errors";
+import { ClientEvent, MatrixClient, 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 { SyncState } from "../../src/sync";
+
+describe("onResumedSync", () => {
+    let batch: IndexedToDeviceBatch | null;
+    let shouldFailSendToDevice: Boolean;
+    let onSendToDeviceFailure: () => void;
+    let onSendToDeviceSuccess: () => void;
+    let resumeSync: (newState: SyncState, oldState: SyncState) => void;
+
+    let store: Store;
+    let mockClient: MatrixClient;
+    let queue: ToDeviceMessageQueue;
+
+    beforeEach(() => {
+        batch = {
+            id: 0,
+            txnId: "123",
+            eventType: "m.dummy",
+            batch: [],
+        };
+
+        shouldFailSendToDevice = true;
+        onSendToDeviceFailure = () => {};
+        onSendToDeviceSuccess = () => {};
+        resumeSync = (newState, oldState) => {
+            shouldFailSendToDevice = false;
+            mockClient.emit(ClientEvent.Sync, newState, oldState);
+        };
+
+        store = new StubStore();
+        store.getOldestToDeviceBatch = jest.fn().mockImplementation(() => {
+            return batch;
+        });
+        store.removeToDeviceBatch = jest.fn().mockImplementation(() => {
+            batch = null;
+        });
+
+        mockClient = getMockClientWithEventEmitter({});
+        mockClient.store = store;
+        mockClient.sendToDevice = jest.fn().mockImplementation(async () => {
+            if (shouldFailSendToDevice) {
+                await Promise.reject(new ConnectionError("")).finally(() => {
+                    setTimeout(onSendToDeviceFailure, 0);
+                });
+            } else {
+                await Promise.resolve({}).finally(() => {
+                    setTimeout(onSendToDeviceSuccess, 0);
+                });
+            }
+        });
+
+        queue = new ToDeviceMessageQueue(mockClient);
+    });
+
+    it("resends queue after connectivity restored", (done) => {
+        onSendToDeviceFailure = () => {
+            expect(store.getOldestToDeviceBatch).toHaveBeenCalledTimes(1);
+            expect(store.removeToDeviceBatch).not.toHaveBeenCalled();
+
+            resumeSync(SyncState.Syncing, SyncState.Catchup);
+            expect(store.getOldestToDeviceBatch).toHaveBeenCalledTimes(2);
+        };
+
+        onSendToDeviceSuccess = () => {
+            expect(store.getOldestToDeviceBatch).toHaveBeenCalledTimes(3);
+            expect(store.removeToDeviceBatch).toHaveBeenCalled();
+            done();
+        };
+
+        queue.start();
+    });
+
+    it("does not resend queue if client sync still catching up", (done) => {
+        onSendToDeviceFailure = () => {
+            expect(store.getOldestToDeviceBatch).toHaveBeenCalledTimes(1);
+            expect(store.removeToDeviceBatch).not.toHaveBeenCalled();
+
+            resumeSync(SyncState.Catchup, SyncState.Catchup);
+            expect(store.getOldestToDeviceBatch).toHaveBeenCalledTimes(1);
+            done();
+        };
+
+        queue.start();
+    });
+
+    it("does not resend queue if connectivity restored after queue stopped", (done) => {
+        onSendToDeviceFailure = () => {
+            expect(store.getOldestToDeviceBatch).toHaveBeenCalledTimes(1);
+            expect(store.removeToDeviceBatch).not.toHaveBeenCalled();
+
+            queue.stop();
+
+            resumeSync(SyncState.Syncing, SyncState.Catchup);
+            expect(store.getOldestToDeviceBatch).toHaveBeenCalledTimes(1);
+            done();
+        };
+
+        queue.start();
+    });
+});

spec/unit/autodiscovery.spec.js

@@ -1,663 +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 MockHttpBackend from "matrix-mock-request";
-
-import * as sdk from "../../src";
-import { AutoDiscovery } from "../../src/autodiscovery";
-
-describe("AutoDiscovery", function() {
-    let httpBackend = null;
-
-    beforeEach(function() {
-        httpBackend = new MockHttpBackend();
-        sdk.request(httpBackend.requestFn);
-    });
-
-    it("should throw an error when no domain is specified", function() {
-        return Promise.all([
-            AutoDiscovery.findClientConfig(/* no args */).then(() => {
-                throw new Error("Expected a failure, not success with no args");
-            }, () => {
-                return true;
-            }),
-
-            AutoDiscovery.findClientConfig("").then(() => {
-                throw new Error("Expected a failure, not success with an empty string");
-            }, () => {
-                return true;
-            }),
-
-            AutoDiscovery.findClientConfig(null).then(() => {
-                throw new Error("Expected a failure, not success with null");
-            }, () => {
-                return true;
-            }),
-
-            AutoDiscovery.findClientConfig(true).then(() => {
-                throw new Error("Expected a failure, not success with a non-string");
-            }, () => {
-                return true;
-            }),
-        ]);
-    });
-
-    it("should return PROMPT when .well-known 404s", function() {
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(404, {});
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_PROMPT when .well-known returns a 500 error", function() {
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(500, {});
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_PROMPT when .well-known returns a 400 error", function() {
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(400, {});
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_PROMPT when .well-known returns an empty body", function() {
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "");
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_PROMPT when .well-known returns not-JSON", function() {
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "abc");
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_PROMPT when .well-known does not have a base_url for " +
-        "m.homeserver (empty string)", function() {
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                base_url: "",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_PROMPT when .well-known does not have a base_url for " +
-        "m.homeserver (no property)", function() {
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {},
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
-        "m.homeserver (disallowed scheme)", function() {
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                base_url: "mxc://example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
-        "m.homeserver (verification failure: 404)", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").respond(404, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                base_url: "https://example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
-                        base_url: "https://example.org",
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
-        "m.homeserver (verification failure: 500)", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").respond(500, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                base_url: "https://example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
-                        base_url: "https://example.org",
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
-        "m.homeserver (verification failure: 200 but wrong content)", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").respond(200, {
-            not_matrix_versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                base_url: "https://example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
-                        base_url: "https://example.org",
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS when .well-known has a verifiably accurate base_url for " +
-        "m.homeserver", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.opts.uri).toEqual("https://example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                base_url: "https://example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-                        base_url: "https://example.org",
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS with the right homeserver URL", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.opts.uri)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (missing base_url)", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.opts.uri)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                not_base_url: "https://identity.example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-
-                        // We still expect the base_url to be here for debugging purposes.
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (empty base_url)", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.opts.uri)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                base_url: "",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-
-                        // We still expect the base_url to be here for debugging purposes.
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (validation error: 404)", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.opts.uri)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/_matrix/identity/api/v1").respond(404, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                base_url: "https://identity.example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-
-                        // We still expect the base_url to be here for debugging purposes.
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
-                        base_url: "https://identity.example.org",
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (validation error: 500)", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.opts.uri)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/_matrix/identity/api/v1").respond(500, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                base_url: "https://identity.example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-
-                        // We still expect the base_url to be here for debugging purposes
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
-                        base_url: "https://identity.example.org",
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS when the identity server configuration is " +
-        "verifiably accurate", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.opts.uri)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/_matrix/identity/api/v1").check((req) => {
-            expect(req.opts.uri)
-                .toEqual("https://identity.example.org/_matrix/identity/api/v1");
-        }).respond(200, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                base_url: "https://identity.example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "SUCCESS",
-                        error: null,
-                        base_url: "https://identity.example.org",
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS and preserve non-standard keys from the " +
-        ".well-known response", function() {
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.opts.uri)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/_matrix/identity/api/v1").check((req) => {
-            expect(req.opts.uri)
-                .toEqual("https://identity.example.org/_matrix/identity/api/v1");
-        }).respond(200, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                base_url: "https://identity.example.org",
-            },
-            "org.example.custom.property": {
-                cupcakes: "yes",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "SUCCESS",
-                        error: null,
-                        base_url: "https://identity.example.org",
-                    },
-                    "org.example.custom.property": {
-                        cupcakes: "yes",
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-});

spec/unit/autodiscovery.spec.ts

@@ -0,0 +1,797 @@
+/*
+Copyright 2018 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 MockHttpBackend from "matrix-mock-request";
+
+import { AutoDiscovery } from "../../src/autodiscovery";
+
+describe("AutoDiscovery", function () {
+    const getHttpBackend = (): MockHttpBackend => {
+        const httpBackend = new MockHttpBackend();
+        AutoDiscovery.setFetchFn(httpBackend.fetchFn as typeof global.fetch);
+        return httpBackend;
+    };
+
+    it("should throw an error when no domain is specified", function () {
+        getHttpBackend();
+        return Promise.all([
+            // @ts-ignore testing no args
+            AutoDiscovery.findClientConfig(/* no args */).then(
+                () => {
+                    throw new Error("Expected a failure, not success with no args");
+                },
+                () => {
+                    return true;
+                },
+            ),
+
+            AutoDiscovery.findClientConfig("").then(
+                () => {
+                    throw new Error("Expected a failure, not success with an empty string");
+                },
+                () => {
+                    return true;
+                },
+            ),
+
+            AutoDiscovery.findClientConfig(null as any).then(
+                () => {
+                    throw new Error("Expected a failure, not success with null");
+                },
+                () => {
+                    return true;
+                },
+            ),
+
+            AutoDiscovery.findClientConfig(true as any).then(
+                () => {
+                    throw new Error("Expected a failure, not success with a non-string");
+                },
+                () => {
+                    return true;
+                },
+            ),
+        ]);
+    });
+
+    it("should return PROMPT when .well-known 404s", function () {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(404, {});
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return FAIL_PROMPT when .well-known returns a 500 error", function () {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(500, {});
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_PROMPT",
+                        error: AutoDiscovery.ERROR_INVALID,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return FAIL_PROMPT when .well-known returns a 400 error", function () {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(400, {});
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_PROMPT",
+                        error: AutoDiscovery.ERROR_INVALID,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return FAIL_PROMPT when .well-known returns an empty body", function () {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "");
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_PROMPT",
+                        error: AutoDiscovery.ERROR_INVALID,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return FAIL_PROMPT when .well-known returns not-JSON", async () => {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "abc", true);
+        const expected = {
+            "m.homeserver": {
+                state: "FAIL_PROMPT",
+                error: AutoDiscovery.ERROR_INVALID,
+                base_url: null,
+            },
+            "m.identity_server": {
+                state: "PROMPT",
+                error: null,
+                base_url: null,
+            },
+        };
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then(expect(expected).toEqual),
+        ]);
+    });
+
+    it("should return FAIL_PROMPT when .well-known does not have a base_url for m.homeserver (empty string)", () => {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+            "m.homeserver": {
+                base_url: "",
+            },
+        });
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_PROMPT",
+                        error: AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return FAIL_PROMPT when .well-known does not have a base_url for m.homeserver (no property)", () => {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+            "m.homeserver": {},
+        });
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_PROMPT",
+                        error: AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return FAIL_ERROR when .well-known has an invalid base_url for m.homeserver (disallowed scheme)", () => {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+            "m.homeserver": {
+                base_url: "mxc://example.org",
+            },
+        });
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_ERROR",
+                        error: AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it(
+        "should return FAIL_ERROR when .well-known has an invalid base_url for " +
+            "m.homeserver (verification failure: 404)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend.when("GET", "/_matrix/client/versions").respond(404, {});
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    base_url: "https://example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "FAIL_ERROR",
+                            error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
+                            base_url: "https://example.org",
+                        },
+                        "m.identity_server": {
+                            state: "PROMPT",
+                            error: null,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return FAIL_ERROR when .well-known has an invalid base_url for " +
+            "m.homeserver (verification failure: 500)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend.when("GET", "/_matrix/client/versions").respond(500, {});
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    base_url: "https://example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "FAIL_ERROR",
+                            error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
+                            base_url: "https://example.org",
+                        },
+                        "m.identity_server": {
+                            state: "PROMPT",
+                            error: null,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return FAIL_ERROR when .well-known has an invalid base_url for " +
+            "m.homeserver (verification failure: 200 but wrong content)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend.when("GET", "/_matrix/client/versions").respond(200, {
+                not_matrix_versions: ["r0.0.1"],
+            });
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    base_url: "https://example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "FAIL_ERROR",
+                            error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
+                            base_url: "https://example.org",
+                        },
+                        "m.identity_server": {
+                            state: "PROMPT",
+                            error: null,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it("should return SUCCESS when .well-known has a verifiably accurate base_url for " + "m.homeserver", function () {
+        const httpBackend = getHttpBackend();
+        httpBackend
+            .when("GET", "/_matrix/client/versions")
+            .check((req) => {
+                expect(req.path).toEqual("https://example.org/_matrix/client/versions");
+            })
+            .respond(200, {
+                versions: ["r0.0.1"],
+            });
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+            "m.homeserver": {
+                base_url: "https://example.org",
+            },
+        });
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "SUCCESS",
+                        error: null,
+                        base_url: "https://example.org",
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return SUCCESS with the right homeserver URL", function () {
+        const httpBackend = getHttpBackend();
+        httpBackend
+            .when("GET", "/_matrix/client/versions")
+            .check((req) => {
+                expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+            })
+            .respond(200, {
+                versions: ["r0.0.1"],
+            });
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+            "m.homeserver": {
+                // Note: we also expect this test to trim the trailing slash
+                base_url: "https://chat.example.org/",
+            },
+        });
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "SUCCESS",
+                        error: null,
+                        base_url: "https://chat.example.org",
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it(
+        "should return SUCCESS / FAIL_PROMPT when the identity server configuration " + "is wrong (missing base_url)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend
+                .when("GET", "/_matrix/client/versions")
+                .check((req) => {
+                    expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+                })
+                .respond(200, {
+                    versions: ["r0.0.1"],
+                });
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    // Note: we also expect this test to trim the trailing slash
+                    base_url: "https://chat.example.org/",
+                },
+                "m.identity_server": {
+                    not_base_url: "https://identity.example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "SUCCESS",
+                            error: null,
+
+                            // We still expect the base_url to be here for debugging purposes.
+                            base_url: "https://chat.example.org",
+                        },
+                        "m.identity_server": {
+                            state: "FAIL_PROMPT",
+                            error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return SUCCESS / FAIL_PROMPT when the identity server configuration " + "is wrong (empty base_url)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend
+                .when("GET", "/_matrix/client/versions")
+                .check((req) => {
+                    expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+                })
+                .respond(200, {
+                    versions: ["r0.0.1"],
+                });
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    // Note: we also expect this test to trim the trailing slash
+                    base_url: "https://chat.example.org/",
+                },
+                "m.identity_server": {
+                    base_url: "",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "SUCCESS",
+                            error: null,
+
+                            // We still expect the base_url to be here for debugging purposes.
+                            base_url: "https://chat.example.org",
+                        },
+                        "m.identity_server": {
+                            state: "FAIL_PROMPT",
+                            error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
+            "is wrong (validation error: 404)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend
+                .when("GET", "/_matrix/client/versions")
+                .check((req) => {
+                    expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+                })
+                .respond(200, {
+                    versions: ["r0.0.1"],
+                });
+            httpBackend.when("GET", "/_matrix/identity/v2").respond(404, {});
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    // Note: we also expect this test to trim the trailing slash
+                    base_url: "https://chat.example.org/",
+                },
+                "m.identity_server": {
+                    base_url: "https://identity.example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "SUCCESS",
+                            error: null,
+
+                            // We still expect the base_url to be here for debugging purposes.
+                            base_url: "https://chat.example.org",
+                        },
+                        "m.identity_server": {
+                            state: "FAIL_PROMPT",
+                            error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
+                            base_url: "https://identity.example.org",
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
+            "is wrong (validation error: 500)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend
+                .when("GET", "/_matrix/client/versions")
+                .check((req) => {
+                    expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+                })
+                .respond(200, {
+                    versions: ["r0.0.1"],
+                });
+            httpBackend.when("GET", "/_matrix/identity/v2").respond(500, {});
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    // Note: we also expect this test to trim the trailing slash
+                    base_url: "https://chat.example.org/",
+                },
+                "m.identity_server": {
+                    base_url: "https://identity.example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "SUCCESS",
+                            error: null,
+
+                            // We still expect the base_url to be here for debugging purposes
+                            base_url: "https://chat.example.org",
+                        },
+                        "m.identity_server": {
+                            state: "FAIL_PROMPT",
+                            error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
+                            base_url: "https://identity.example.org",
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it("should return SUCCESS when the identity server configuration is " + "verifiably accurate", function () {
+        const httpBackend = getHttpBackend();
+        httpBackend
+            .when("GET", "/_matrix/client/versions")
+            .check((req) => {
+                expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+            })
+            .respond(200, {
+                versions: ["r0.0.1"],
+            });
+        httpBackend
+            .when("GET", "/_matrix/identity/v2")
+            .check((req) => {
+                expect(req.path).toEqual("https://identity.example.org/_matrix/identity/v2");
+            })
+            .respond(200, {});
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+            "m.homeserver": {
+                // Note: we also expect this test to trim the trailing slash
+                base_url: "https://chat.example.org/",
+            },
+            "m.identity_server": {
+                base_url: "https://identity.example.org",
+            },
+        });
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "SUCCESS",
+                        error: null,
+                        base_url: "https://chat.example.org",
+                    },
+                    "m.identity_server": {
+                        state: "SUCCESS",
+                        error: null,
+                        base_url: "https://identity.example.org",
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return SUCCESS and preserve non-standard keys from the " + ".well-known response", function () {
+        const httpBackend = getHttpBackend();
+        httpBackend
+            .when("GET", "/_matrix/client/versions")
+            .check((req) => {
+                expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+            })
+            .respond(200, {
+                versions: ["r0.0.1"],
+            });
+        httpBackend
+            .when("GET", "/_matrix/identity/v2")
+            .check((req) => {
+                expect(req.path).toEqual("https://identity.example.org/_matrix/identity/v2");
+            })
+            .respond(200, {});
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+            "m.homeserver": {
+                // Note: we also expect this test to trim the trailing slash
+                base_url: "https://chat.example.org/",
+            },
+            "m.identity_server": {
+                base_url: "https://identity.example.org",
+            },
+            "org.example.custom.property": {
+                cupcakes: "yes",
+            },
+        });
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "SUCCESS",
+                        error: null,
+                        base_url: "https://chat.example.org",
+                    },
+                    "m.identity_server": {
+                        state: "SUCCESS",
+                        error: null,
+                        base_url: "https://identity.example.org",
+                    },
+                    "org.example.custom.property": {
+                        cupcakes: "yes",
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return FAIL_PROMPT for connection errors", () => {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").fail(0, undefined!);
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_PROMPT",
+                        error: AutoDiscovery.ERROR_INVALID,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return FAIL_PROMPT for fetch errors", () => {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").fail(0, new Error("CORS or something"));
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_PROMPT",
+                        error: AutoDiscovery.ERROR_INVALID,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+
+    it("should return FAIL_PROMPT for invalid JSON", () => {
+        const httpBackend = getHttpBackend();
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "<html>", true);
+        return Promise.all([
+            httpBackend.flushAllExpected(),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_PROMPT",
+                        error: AutoDiscovery.ERROR_INVALID,
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
+        ]);
+    });
+});

spec/unit/content-helpers.spec.ts

@@ -14,34 +14,29 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { REFERENCE_RELATION } from "matrix-events-sdk";
-
 import { LocationAssetType, M_ASSET, M_LOCATION, M_TIMESTAMP } from "../../src/@types/location";
 import { M_TOPIC } from "../../src/@types/topic";
 import {
     makeBeaconContent,
     makeBeaconInfoContent,
     makeTopicContent,
+    parseBeaconContent,
     parseTopicContent,
 } from "../../src/content-helpers";
+import { REFERENCE_RELATION } from "../../src/@types/extensible_events";
 
-describe('Beacon content helpers', () => {
-    describe('makeBeaconInfoContent()', () => {
+describe("Beacon content helpers", () => {
+    describe("makeBeaconInfoContent()", () => {
         const mockDateNow = 123456789;
         beforeEach(() => {
-            jest.spyOn(global.Date, 'now').mockReturnValue(mockDateNow);
+            jest.spyOn(global.Date, "now").mockReturnValue(mockDateNow);
         });
         afterAll(() => {
-            jest.spyOn(global.Date, 'now').mockRestore();
+            jest.spyOn(global.Date, "now").mockRestore();
         });
-        it('create fully defined event content', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                LocationAssetType.Pin,
-            )).toEqual({
-                description: 'nice beacon_info',
+        it("create fully defined event content", () => {
+            expect(makeBeaconInfoContent(1234, true, "nice beacon_info", LocationAssetType.Pin)).toEqual({
+                description: "nice beacon_info",
                 timeout: 1234,
                 live: true,
                 [M_TIMESTAMP.name]: mockDateNow,
@@ -51,142 +46,213 @@ describe('Beacon content helpers', () => {
             });
         });
 
-        it('defaults timestamp to current time', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                LocationAssetType.Pin,
-            )).toEqual(expect.objectContaining({
-                [M_TIMESTAMP.name]: mockDateNow,
-            }));
+        it("defaults timestamp to current time", () => {
+            expect(makeBeaconInfoContent(1234, true, "nice beacon_info", LocationAssetType.Pin)).toEqual(
+                expect.objectContaining({
+                    [M_TIMESTAMP.name]: mockDateNow,
+                }),
+            );
         });
 
-        it('uses timestamp when provided', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                LocationAssetType.Pin,
-                99999,
-            )).toEqual(expect.objectContaining({
-                [M_TIMESTAMP.name]: 99999,
-            }));
+        it("uses timestamp when provided", () => {
+            expect(makeBeaconInfoContent(1234, true, "nice beacon_info", LocationAssetType.Pin, 99999)).toEqual(
+                expect.objectContaining({
+                    [M_TIMESTAMP.name]: 99999,
+                }),
+            );
         });
 
-        it('defaults asset type to self when not set', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                // no assetType passed
-            )).toEqual(expect.objectContaining({
-                [M_ASSET.name]: {
-                    type: LocationAssetType.Self,
-                },
-            }));
+        it("defaults asset type to self when not set", () => {
+            expect(
+                makeBeaconInfoContent(
+                    1234,
+                    true,
+                    "nice beacon_info",
+                    // no assetType passed
+                ),
+            ).toEqual(
+                expect.objectContaining({
+                    [M_ASSET.name]: {
+                        type: LocationAssetType.Self,
+                    },
+                }),
+            );
         });
     });
 
-    describe('makeBeaconContent()', () => {
-        it('creates event content without description', () => {
-            expect(makeBeaconContent(
-                'geo:foo',
-                123,
-                '$1234',
-                // no description
-            )).toEqual({
+    describe("makeBeaconContent()", () => {
+        it("creates event content without description", () => {
+            expect(
+                makeBeaconContent(
+                    "geo:foo",
+                    123,
+                    "$1234",
+                    // no description
+                ),
+            ).toEqual({
                 [M_LOCATION.name]: {
                     description: undefined,
-                    uri: 'geo:foo',
+                    uri: "geo:foo",
                 },
                 [M_TIMESTAMP.name]: 123,
                 "m.relates_to": {
                     rel_type: REFERENCE_RELATION.name,
-                    event_id: '$1234',
+                    event_id: "$1234",
                 },
             });
         });
 
-        it('creates event content with description', () => {
-            expect(makeBeaconContent(
-                'geo:foo',
-                123,
-                '$1234',
-                'test description',
-            )).toEqual({
+        it("creates event content with description", () => {
+            expect(makeBeaconContent("geo:foo", 123, "$1234", "test description")).toEqual({
                 [M_LOCATION.name]: {
-                    description: 'test description',
-                    uri: 'geo:foo',
+                    description: "test description",
+                    uri: "geo:foo",
                 },
                 [M_TIMESTAMP.name]: 123,
                 "m.relates_to": {
                     rel_type: REFERENCE_RELATION.name,
-                    event_id: '$1234',
+                    event_id: "$1234",
                 },
             });
         });
     });
+
+    describe("parseBeaconContent()", () => {
+        it("should not explode when parsing an invalid beacon", () => {
+            // deliberate cast to simulate wire content being invalid
+            const result = parseBeaconContent({} as any);
+            expect(result).toEqual({
+                description: undefined,
+                uri: undefined,
+                timestamp: undefined,
+            });
+        });
+
+        it("should parse unstable values", () => {
+            const uri = "urigoeshere";
+            const description = "descriptiongoeshere";
+            const timestamp = 1234;
+            const result = parseBeaconContent({
+                "org.matrix.msc3488.location": {
+                    uri,
+                    description,
+                },
+                "org.matrix.msc3488.ts": timestamp,
+
+                // relationship not used - just here to satisfy types
+                "m.relates_to": {
+                    rel_type: "m.reference",
+                    event_id: "$unused",
+                },
+            });
+            expect(result).toEqual({
+                description,
+                uri,
+                timestamp,
+            });
+        });
+
+        it("should parse stable values", () => {
+            const uri = "urigoeshere";
+            const description = "descriptiongoeshere";
+            const timestamp = 1234;
+            const result = parseBeaconContent({
+                "m.location": {
+                    uri,
+                    description,
+                },
+                "m.ts": timestamp,
+
+                // relationship not used - just here to satisfy types
+                "m.relates_to": {
+                    rel_type: "m.reference",
+                    event_id: "$unused",
+                },
+            });
+            expect(result).toEqual({
+                description,
+                uri,
+                timestamp,
+            });
+        });
+    });
 });
 
-describe('Topic content helpers', () => {
-    describe('makeTopicContent()', () => {
-        it('creates fully defined event content without html', () => {
+describe("Topic content helpers", () => {
+    describe("makeTopicContent()", () => {
+        it("creates fully defined event content without html", () => {
             expect(makeTopicContent("pizza")).toEqual({
                 topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                    mimetype: "text/plain",
-                }],
+                [M_TOPIC.name]: [
+                    {
+                        body: "pizza",
+                        mimetype: "text/plain",
+                    },
+                ],
             });
         });
 
-        it('creates fully defined event content with html', () => {
+        it("creates fully defined event content with html", () => {
             expect(makeTopicContent("pizza", "<b>pizza</b>")).toEqual({
                 topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                    mimetype: "text/plain",
-                }, {
-                    body: "<b>pizza</b>",
-                    mimetype: "text/html",
-                }],
+                [M_TOPIC.name]: [
+                    {
+                        body: "pizza",
+                        mimetype: "text/plain",
+                    },
+                    {
+                        body: "<b>pizza</b>",
+                        mimetype: "text/html",
+                    },
+                ],
             });
         });
     });
 
-    describe('parseTopicContent()', () => {
-        it('parses event content with plain text topic without mimetype', () => {
-            expect(parseTopicContent({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                }],
-            })).toEqual({
+    describe("parseTopicContent()", () => {
+        it("parses event content with plain text topic without mimetype", () => {
+            expect(
+                parseTopicContent({
+                    topic: "pizza",
+                    [M_TOPIC.name]: [
+                        {
+                            body: "pizza",
+                        },
+                    ],
+                }),
+            ).toEqual({
                 text: "pizza",
             });
         });
 
-        it('parses event content with plain text topic', () => {
-            expect(parseTopicContent({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                    mimetype: "text/plain",
-                }],
-            })).toEqual({
+        it("parses event content with plain text topic", () => {
+            expect(
+                parseTopicContent({
+                    topic: "pizza",
+                    [M_TOPIC.name]: [
+                        {
+                            body: "pizza",
+                            mimetype: "text/plain",
+                        },
+                    ],
+                }),
+            ).toEqual({
                 text: "pizza",
             });
         });
 
-        it('parses event content with html topic', () => {
-            expect(parseTopicContent({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "<b>pizza</b>",
-                    mimetype: "text/html",
-                }],
-            })).toEqual({
+        it("parses event content with html topic", () => {
+            expect(
+                parseTopicContent({
+                    topic: "pizza",
+                    [M_TOPIC.name]: [
+                        {
+                            body: "<b>pizza</b>",
+                            mimetype: "text/html",
+                        },
+                    ],
+                }),
+            ).toEqual({
                 text: "pizza",
                 html: "<b>pizza</b>",
             });

spec/unit/content-repo.spec.ts

@@ -1,55 +1,61 @@
+/*
+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 { getHttpUriForMxc } from "../../src/content-repo";
 
-describe("ContentRepo", function() {
+describe("ContentRepo", function () {
     const baseUrl = "https://my.home.server";
 
-    describe("getHttpUriForMxc", function() {
-        it("should do nothing to HTTP URLs when allowing direct links", function() {
+    describe("getHttpUriForMxc", function () {
+        it("should do nothing to HTTP URLs when allowing direct links", function () {
             const httpUrl = "http://example.com/image.jpeg";
-            expect(
-                getHttpUriForMxc(
-                    baseUrl, httpUrl, undefined, undefined, undefined, true,
-                ),
-            ).toEqual(httpUrl);
+            expect(getHttpUriForMxc(baseUrl, httpUrl, undefined, undefined, undefined, true)).toEqual(httpUrl);
         });
 
-        it("should return the empty string HTTP URLs by default", function() {
+        it("should return the empty string HTTP URLs by default", function () {
             const httpUrl = "http://example.com/image.jpeg";
             expect(getHttpUriForMxc(baseUrl, httpUrl)).toEqual("");
         });
 
-        it("should return a download URL if no width/height/resize are specified",
-        function() {
+        it("should return a download URL if no width/height/resize are specified", function () {
             const mxcUri = "mxc://server.name/resourceid";
             expect(getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
                 baseUrl + "/_matrix/media/r0/download/server.name/resourceid",
             );
         });
 
-        it("should return the empty string for null input", function() {
-            expect(getHttpUriForMxc(null)).toEqual("");
+        it("should return the empty string for null input", function () {
+            expect(getHttpUriForMxc(null as any, "")).toEqual("");
         });
 
-        it("should return a thumbnail URL if a width/height/resize is specified",
-        function() {
+        it("should return a thumbnail URL if a width/height/resize is specified", function () {
             const mxcUri = "mxc://server.name/resourceid";
             expect(getHttpUriForMxc(baseUrl, mxcUri, 32, 64, "crop")).toEqual(
-                baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" +
-                "?width=32&height=64&method=crop",
+                baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" + "?width=32&height=64&method=crop",
             );
         });
 
-        it("should put fragments from mxc:// URIs after any query parameters",
-        function() {
+        it("should put fragments from mxc:// URIs after any query parameters", function () {
             const mxcUri = "mxc://server.name/resourceid#automade";
             expect(getHttpUriForMxc(baseUrl, mxcUri, 32)).toEqual(
-                baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" +
-                "?width=32#automade",
+                baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" + "?width=32#automade",
             );
         });
 
-        it("should put fragments from mxc:// URIs at the end of the HTTP URI",
-        function() {
+        it("should put fragments from mxc:// URIs at the end of the HTTP URI", function () {
             const mxcUri = "mxc://server.name/resourceid#automade";
             expect(getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
                 baseUrl + "/_matrix/media/r0/download/server.name/resourceid#automade",

spec/unit/crypto.spec.js

@@ -1,470 +0,0 @@
-import '../olm-loader';
-// eslint-disable-next-line no-restricted-imports
-import { EventEmitter } from "events";
-
-import { Crypto } from "../../src/crypto";
-import { MemoryCryptoStore } from "../../src/crypto/store/memory-crypto-store";
-import { MockStorageApi } from "../MockStorageApi";
-import { TestClient } from "../TestClient";
-import { MatrixEvent } from "../../src/models/event";
-import { Room } from "../../src/models/room";
-import * as olmlib from "../../src/crypto/olmlib";
-import { sleep } from "../../src/utils";
-import { CRYPTO_ENABLED } from "../../src/client";
-import { DeviceInfo } from "../../src/crypto/deviceinfo";
-import { logger } from '../../src/logger';
-import { MemoryStore } from "../../src";
-
-const Olm = global.Olm;
-
-function awaitEvent(emitter, event) {
-    return new Promise((resolve, reject) => {
-        emitter.once(event, (result) => {
-            resolve(result);
-        });
-    });
-}
-
-async function keyshareEventForEvent(client, event, index) {
-    const roomId = event.getRoomId();
-    const eventContent = event.getWireContent();
-    const key = await client.crypto.olmDevice.getInboundGroupSessionKey(
-        roomId,
-        eventContent.sender_key,
-        eventContent.session_id,
-        index,
-    );
-    const ksEvent = new MatrixEvent({
-        type: "m.forwarded_room_key",
-        sender: client.getUserId(),
-        content: {
-            algorithm: olmlib.MEGOLM_ALGORITHM,
-            room_id: roomId,
-            sender_key: eventContent.sender_key,
-            sender_claimed_ed25519_key: key.sender_claimed_ed25519_key,
-            session_id: eventContent.session_id,
-            session_key: key.key,
-            chain_index: key.chain_index,
-            forwarding_curve25519_key_chain:
-            key.forwarding_curve_key_chain,
-        },
-    });
-    // make onRoomKeyEvent think this was an encrypted event
-    ksEvent.senderCurve25519Key = "akey";
-    return ksEvent;
-}
-
-describe("Crypto", function() {
-    if (!CRYPTO_ENABLED) {
-        return;
-    }
-
-    beforeAll(function() {
-        return Olm.init();
-    });
-
-    it("Crypto exposes the correct olm library version", function() {
-        expect(Crypto.getOlmVersion()[0]).toEqual(3);
-    });
-
-    describe("encrypted events", function() {
-        it("provides encryption information", async function() {
-            const client = (new TestClient(
-                "@alice:example.com", "deviceid",
-            )).client;
-            await client.initCrypto();
-
-            // unencrypted event
-            const event = {
-                getId: () => "$event_id",
-                getSenderKey: () => null,
-                getWireContent: () => {return {};},
-            };
-
-            let encryptionInfo = client.getEventEncryptionInfo(event);
-            expect(encryptionInfo.encrypted).toBeFalsy();
-
-            // unknown sender (e.g. deleted device), forwarded megolm key (untrusted)
-            event.getSenderKey = () => 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI';
-            event.getWireContent = () => {return { algorithm: olmlib.MEGOLM_ALGORITHM };};
-            event.getForwardingCurve25519KeyChain = () => ["not empty"];
-            event.isKeySourceUntrusted = () => false;
-            event.getClaimedEd25519Key =
-                () => 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
-
-            encryptionInfo = client.getEventEncryptionInfo(event);
-            expect(encryptionInfo.encrypted).toBeTruthy();
-            expect(encryptionInfo.authenticated).toBeFalsy();
-            expect(encryptionInfo.sender).toBeFalsy();
-
-            // known sender, megolm key from backup
-            event.getForwardingCurve25519KeyChain = () => [];
-            event.isKeySourceUntrusted = () => true;
-            const device = new DeviceInfo("FLIBBLE");
-            device.keys["curve25519:FLIBBLE"] =
-                'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI';
-            device.keys["ed25519:FLIBBLE"] =
-                'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
-            client.crypto.deviceList.getDeviceByIdentityKey = () => device;
-
-            encryptionInfo = client.getEventEncryptionInfo(event);
-            expect(encryptionInfo.encrypted).toBeTruthy();
-            expect(encryptionInfo.authenticated).toBeFalsy();
-            expect(encryptionInfo.sender).toBeTruthy();
-            expect(encryptionInfo.mismatchedSender).toBeFalsy();
-
-            // known sender, trusted megolm key, but bad ed25519key
-            event.isKeySourceUntrusted = () => false;
-            device.keys["ed25519:FLIBBLE"] =
-                'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB';
-
-            encryptionInfo = client.getEventEncryptionInfo(event);
-            expect(encryptionInfo.encrypted).toBeTruthy();
-            expect(encryptionInfo.authenticated).toBeTruthy();
-            expect(encryptionInfo.sender).toBeTruthy();
-            expect(encryptionInfo.mismatchedSender).toBeTruthy();
-
-            client.stopClient();
-        });
-    });
-
-    describe('Session management', function() {
-        const otkResponse = {
-            one_time_keys: {
-                '@alice:home.server': {
-                    aliceDevice: {
-                        'signed_curve25519:FLIBBLE': {
-                            key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
-                            signatures: {
-                                '@alice:home.server': {
-                                    'ed25519:aliceDevice': 'totally a valid signature',
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        let crypto;
-        let mockBaseApis;
-        let mockRoomList;
-
-        let fakeEmitter;
-
-        beforeEach(async function() {
-            const mockStorage = new MockStorageApi();
-            const clientStore = new MemoryStore({ localStorage: mockStorage });
-            const cryptoStore = new MemoryCryptoStore(mockStorage);
-
-            cryptoStore.storeEndToEndDeviceData({
-                devices: {
-                    '@bob:home.server': {
-                        'BOBDEVICE': {
-                            keys: {
-                                'curve25519:BOBDEVICE': 'this is a key',
-                            },
-                        },
-                    },
-                },
-                trackingStatus: {},
-            });
-
-            mockBaseApis = {
-                sendToDevice: jest.fn(),
-                getKeyBackupVersion: jest.fn(),
-                isGuest: jest.fn(),
-            };
-            mockRoomList = {};
-
-            fakeEmitter = new EventEmitter();
-
-            crypto = new Crypto(
-                mockBaseApis,
-                "@alice:home.server",
-                "FLIBBLE",
-                clientStore,
-                cryptoStore,
-                mockRoomList,
-            );
-            crypto.registerEventHandlers(fakeEmitter);
-            await crypto.init();
-        });
-
-        afterEach(async function() {
-            await crypto.stop();
-        });
-
-        it("restarts wedged Olm sessions", async function() {
-            const prom = new Promise((resolve) => {
-                mockBaseApis.claimOneTimeKeys = function() {
-                    resolve();
-                    return otkResponse;
-                };
-            });
-
-            fakeEmitter.emit('toDeviceEvent', {
-                getId: jest.fn().mockReturnValue("$wedged"),
-                getType: jest.fn().mockReturnValue('m.room.message'),
-                getContent: jest.fn().mockReturnValue({
-                    msgtype: 'm.bad.encrypted',
-                }),
-                getWireContent: jest.fn().mockReturnValue({
-                    algorithm: 'm.olm.v1.curve25519-aes-sha2',
-                    sender_key: 'this is a key',
-                }),
-                getSender: jest.fn().mockReturnValue('@bob:home.server'),
-            });
-
-            await prom;
-        });
-    });
-
-    describe('Key requests', function() {
-        let aliceClient;
-        let bobClient;
-
-        beforeEach(async function() {
-            aliceClient = (new TestClient(
-                "@alice:example.com", "alicedevice",
-            )).client;
-            bobClient = (new TestClient(
-                "@bob:example.com", "bobdevice",
-            )).client;
-            await aliceClient.initCrypto();
-            await bobClient.initCrypto();
-        });
-
-        afterEach(async function() {
-            aliceClient.stopClient();
-            bobClient.stopClient();
-        });
-
-        it("does not cancel keyshare requests if some messages are not decrypted", async function() {
-            const encryptionCfg = {
-                "algorithm": "m.megolm.v1.aes-sha2",
-            };
-            const roomId = "!someroom";
-            const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
-            const bobRoom = new Room(roomId, bobClient, "@bob:example.com", {});
-            aliceClient.store.storeRoom(aliceRoom);
-            bobClient.store.storeRoom(bobRoom);
-            await aliceClient.setRoomEncryption(roomId, encryptionCfg);
-            await bobClient.setRoomEncryption(roomId, encryptionCfg);
-            const events = [
-                new MatrixEvent({
-                    type: "m.room.message",
-                    sender: "@alice:example.com",
-                    room_id: roomId,
-                    event_id: "$1",
-                    content: {
-                        msgtype: "m.text",
-                        body: "1",
-                    },
-                }),
-                new MatrixEvent({
-                    type: "m.room.message",
-                    sender: "@alice:example.com",
-                    room_id: roomId,
-                    event_id: "$2",
-                    content: {
-                        msgtype: "m.text",
-                        body: "2",
-                    },
-                }),
-            ];
-            await Promise.all(events.map(async (event) => {
-                // alice encrypts each event, and then bob tries to decrypt
-                // them without any keys, so that they'll be in pending
-                await aliceClient.crypto.encryptEvent(event, aliceRoom);
-                event.clearEvent = undefined;
-                event.senderCurve25519Key = null;
-                event.claimedEd25519Key = null;
-                try {
-                    await bobClient.crypto.decryptEvent(event);
-                } catch (e) {
-                    // we expect this to fail because we don't have the
-                    // decryption keys yet
-                }
-            }));
-
-            const bobDecryptor = bobClient.crypto.getRoomDecryptor(
-                roomId, olmlib.MEGOLM_ALGORITHM,
-            );
-
-            let eventPromise = Promise.all(events.map((ev) => {
-                return awaitEvent(ev, "Event.decrypted");
-            }));
-
-            // keyshare the session key starting at the second message, so
-            // the first message can't be decrypted yet, but the second one
-            // can
-            let ksEvent = await keyshareEventForEvent(aliceClient, events[1], 1);
-            await bobDecryptor.onRoomKeyEvent(ksEvent);
-            await eventPromise;
-            expect(events[0].getContent().msgtype).toBe("m.bad.encrypted");
-            expect(events[1].getContent().msgtype).not.toBe("m.bad.encrypted");
-
-            const cryptoStore = bobClient.cryptoStore;
-            const eventContent = events[0].getWireContent();
-            const senderKey = eventContent.sender_key;
-            const sessionId = eventContent.session_id;
-            const roomKeyRequestBody = {
-                algorithm: olmlib.MEGOLM_ALGORITHM,
-                room_id: roomId,
-                sender_key: senderKey,
-                session_id: sessionId,
-            };
-            // the room key request should still be there, since we haven't
-            // decrypted everything
-            expect(await cryptoStore.getOutgoingRoomKeyRequest(roomKeyRequestBody)).toBeDefined();
-
-            // keyshare the session key starting at the first message, so
-            // that it can now be decrypted
-            eventPromise = awaitEvent(events[0], "Event.decrypted");
-            ksEvent = await keyshareEventForEvent(aliceClient, events[0], 0);
-            await bobDecryptor.onRoomKeyEvent(ksEvent);
-            await eventPromise;
-            expect(events[0].getContent().msgtype).not.toBe("m.bad.encrypted");
-            await sleep(1);
-            // the room key request should be gone since we've now decrypted everything
-            expect(await cryptoStore.getOutgoingRoomKeyRequest(roomKeyRequestBody)).toBeFalsy();
-        });
-
-        it("should error if a forwarded room key lacks a content.sender_key", async function() {
-            const encryptionCfg = {
-                "algorithm": "m.megolm.v1.aes-sha2",
-            };
-            const roomId = "!someroom";
-            const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
-            const bobRoom = new Room(roomId, bobClient, "@bob:example.com", {});
-            aliceClient.store.storeRoom(aliceRoom);
-            bobClient.store.storeRoom(bobRoom);
-            await aliceClient.setRoomEncryption(roomId, encryptionCfg);
-            await bobClient.setRoomEncryption(roomId, encryptionCfg);
-            const event = new MatrixEvent({
-                type: "m.room.message",
-                sender: "@alice:example.com",
-                room_id: roomId,
-                event_id: "$1",
-                content: {
-                    msgtype: "m.text",
-                    body: "1",
-                },
-            });
-            // alice encrypts each event, and then bob tries to decrypt
-            // them without any keys, so that they'll be in pending
-            await aliceClient.crypto.encryptEvent(event, aliceRoom);
-            event.clearEvent = undefined;
-            event.senderCurve25519Key = null;
-            event.claimedEd25519Key = null;
-            try {
-                await bobClient.crypto.decryptEvent(event);
-            } catch (e) {
-                // we expect this to fail because we don't have the
-                // decryption keys yet
-            }
-
-            const bobDecryptor = bobClient.crypto.getRoomDecryptor(
-                roomId, olmlib.MEGOLM_ALGORITHM,
-            );
-
-            const ksEvent = await keyshareEventForEvent(aliceClient, event, 1);
-            ksEvent.getContent().sender_key = undefined; // test
-            bobClient.crypto.addInboundGroupSession = jest.fn();
-            await bobDecryptor.onRoomKeyEvent(ksEvent);
-            expect(bobClient.crypto.addInboundGroupSession).not.toHaveBeenCalled();
-        });
-
-        it("creates a new keyshare request if we request a keyshare", async function() {
-            // make sure that cancelAndResend... creates a new keyshare request
-            // if there wasn't an already-existing one
-            const event = new MatrixEvent({
-                sender: "@bob:example.com",
-                room_id: "!someroom",
-                content: {
-                    algorithm: olmlib.MEGOLM_ALGORITHM,
-                    session_id: "sessionid",
-                    sender_key: "senderkey",
-                },
-            });
-            await aliceClient.cancelAndResendEventRoomKeyRequest(event);
-            const cryptoStore = aliceClient.cryptoStore;
-            const roomKeyRequestBody = {
-                algorithm: olmlib.MEGOLM_ALGORITHM,
-                room_id: "!someroom",
-                session_id: "sessionid",
-                sender_key: "senderkey",
-            };
-            expect(await cryptoStore.getOutgoingRoomKeyRequest(roomKeyRequestBody))
-                .toBeDefined();
-        });
-
-        it("uses a new txnid for re-requesting keys", async function() {
-            jest.useFakeTimers();
-
-            const event = new MatrixEvent({
-                sender: "@bob:example.com",
-                room_id: "!someroom",
-                content: {
-                    algorithm: olmlib.MEGOLM_ALGORITHM,
-                    session_id: "sessionid",
-                    sender_key: "senderkey",
-                },
-            });
-            // replace Alice's sendToDevice function with a mock
-            aliceClient.sendToDevice = jest.fn().mockResolvedValue(undefined);
-            aliceClient.startClient();
-
-            // make a room key request, and record the transaction ID for the
-            // sendToDevice call
-            await aliceClient.cancelAndResendEventRoomKeyRequest(event);
-            // key requests get queued until the sync has finished, but we don't
-            // let the client set up enough for that to happen, so gut-wrench a bit
-            // to force it to send now.
-            aliceClient.crypto.outgoingRoomKeyRequestManager.sendQueuedRequests();
-            jest.runAllTimers();
-            await Promise.resolve();
-            expect(aliceClient.sendToDevice).toBeCalledTimes(1);
-            const txnId = aliceClient.sendToDevice.mock.calls[0][2];
-
-            // give the room key request manager time to update the state
-            // of the request
-            await Promise.resolve();
-
-            // cancel and resend the room key request
-            await aliceClient.cancelAndResendEventRoomKeyRequest(event);
-            jest.runAllTimers();
-            await Promise.resolve();
-            // cancelAndResend will call sendToDevice twice:
-            // the first call to sendToDevice will be the cancellation
-            // the second call to sendToDevice will be the key request
-            expect(aliceClient.sendToDevice).toBeCalledTimes(3);
-            expect(aliceClient.sendToDevice.mock.calls[2][2]).not.toBe(txnId);
-        });
-    });
-
-    describe('Secret storage', function() {
-        it("creates secret storage even if there is no keyInfo", async function() {
-            jest.spyOn(logger, 'log').mockImplementation(() => {});
-            jest.setTimeout(10000);
-            const client = (new TestClient("@a:example.com", "dev")).client;
-            await client.initCrypto();
-            client.crypto.getSecretStorageKey = async () => null;
-            client.crypto.isCrossSigningReady = async () => false;
-            client.crypto.baseApis.uploadDeviceSigningKeys = () => null;
-            client.crypto.baseApis.setAccountData = () => null;
-            client.crypto.baseApis.uploadKeySignatures = () => null;
-            client.crypto.baseApis.http.authedRequest = () => null;
-            const createSecretStorageKey = async () => {
-                return {
-                    keyInfo: undefined, // Returning undefined here used to cause a crash
-                    privateKey: Uint8Array.of(32, 33),
-                };
-            };
-            await client.crypto.bootstrapSecretStorage({
-                createSecretStorageKey,
-            });
-            client.stopClient();
-        });
-    });
-});

spec/unit/crypto/CrossSigningInfo.spec.ts

@@ -14,28 +14,21 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../olm-loader';
-import {
-    CrossSigningInfo,
-    createCryptoStoreCacheCallbacks,
-} from '../../../src/crypto/CrossSigning';
-import {
-    IndexedDBCryptoStore,
-} from '../../../src/crypto/store/indexeddb-crypto-store';
-import { MemoryCryptoStore } from '../../../src/crypto/store/memory-crypto-store';
-import 'fake-indexeddb/auto';
-import 'jest-localstorage-mock';
+import "../../olm-loader";
+import { CrossSigningInfo, createCryptoStoreCacheCallbacks } from "../../../src/crypto/CrossSigning";
+import { IndexedDBCryptoStore } from "../../../src/crypto/store/indexeddb-crypto-store";
+import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
+import "fake-indexeddb/auto";
+import "jest-localstorage-mock";
 import { OlmDevice } from "../../../src/crypto/OlmDevice";
-import { logger } from '../../../src/logger';
+import { logger } from "../../../src/logger";
 
 const userId = "@alice:example.com";
 
 // Private key for tests only
 const testKey = new Uint8Array([
-    0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82,
-    0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef,
-    0xae, 0xb1, 0x05, 0xc1, 0xe7, 0x62, 0x78, 0xa6,
-    0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
+    0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82, 0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef, 0xae, 0xb1, 0x05,
+    0xc1, 0xe7, 0x62, 0x78, 0xa6, 0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
 ]);
 
 const types = [
@@ -50,13 +43,13 @@ badKey[0] ^= 1;
 
 const masterKeyPub = "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk";
 
-describe("CrossSigningInfo.getCrossSigningKey", function() {
+describe("CrossSigningInfo.getCrossSigningKey", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn("Not running megolm backup unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return global.Olm.init();
     });
 
@@ -65,13 +58,12 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
         await expect(info.getCrossSigningKey("master")).rejects.toThrow();
     });
 
-    it.each(types)("should throw if the callback returns falsey",
-        async ({ type, shouldCache }) => {
-            const info = new CrossSigningInfo(userId, {
-                getCrossSigningKey: async () => false as unknown as Uint8Array,
-            });
-            await expect(info.getCrossSigningKey(type)).rejects.toThrow("falsey");
+    it.each(types)("should throw if the callback returns falsey", async ({ type, shouldCache }) => {
+        const info = new CrossSigningInfo(userId, {
+            getCrossSigningKey: async () => false as unknown as Uint8Array,
         });
+        await expect(info.getCrossSigningKey(type)).rejects.toThrow("falsey");
+    });
 
     it("should throw if the expected key doesn't come back", async () => {
         const info = new CrossSigningInfo(userId, {
@@ -96,63 +88,8 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
         }
     });
 
-    it.each(types)("should request a key from the cache callback (if set)" +
-                   " and does not call app if one is found" +
-                   " %o",
-    async ({ type, shouldCache }) => {
-        const getCrossSigningKey = jest.fn().mockImplementation(() => {
-            if (shouldCache) {
-                return Promise.reject(new Error("Regular callback called"));
-            } else {
-                return Promise.resolve(testKey);
-            }
-        });
-        const getCrossSigningKeyCache = jest.fn().mockResolvedValue(testKey);
-        const info = new CrossSigningInfo(
-            userId,
-            { getCrossSigningKey },
-            { getCrossSigningKeyCache },
-        );
-        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-        expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-        if (shouldCache) {
-            expect(getCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
-        }
-    });
-
-    it.each(types)("should store a key with the cache callback (if set)",
-        async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-            const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-            const info = new CrossSigningInfo(
-                userId,
-                { getCrossSigningKey },
-                { storeCrossSigningKeyCache },
-            );
-            const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-            expect(pubKey).toEqual(masterKeyPub);
-            expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(shouldCache ? 1 : 0);
-            if (shouldCache) {
-                expect(storeCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
-                expect(storeCrossSigningKeyCache.mock.calls[0][1]).toBe(testKey);
-            }
-        });
-
-    it.each(types)("does not store a bad key to the cache",
-        async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockResolvedValue(badKey);
-            const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-            const info = new CrossSigningInfo(
-                userId,
-                { getCrossSigningKey },
-                { storeCrossSigningKeyCache },
-            );
-            await expect(info.getCrossSigningKey(type, masterKeyPub)).rejects.toThrow();
-            expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(0);
-        });
-
-    it.each(types)("does not store a value to the cache if it came from the cache",
+    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) {
@@ -162,56 +99,98 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
                 }
             });
             const getCrossSigningKeyCache = jest.fn().mockResolvedValue(testKey);
-            const storeCrossSigningKeyCache = jest.fn().mockRejectedValue(
-                new Error("Tried to store a value from cache"),
-            );
+            const info = new CrossSigningInfo(userId, { getCrossSigningKey }, { getCrossSigningKeyCache });
+            const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
+            expect(pubKey).toEqual(masterKeyPub);
+            expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
+            if (shouldCache) {
+                expect(getCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
+            }
+        },
+    );
+
+    it.each(types)("should store a key with the cache callback (if set)", async ({ type, shouldCache }) => {
+        const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
+        const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
+        const info = new CrossSigningInfo(userId, { getCrossSigningKey }, { storeCrossSigningKeyCache });
+        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
+        expect(pubKey).toEqual(masterKeyPub);
+        expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(shouldCache ? 1 : 0);
+        if (shouldCache) {
+            expect(storeCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
+            expect(storeCrossSigningKeyCache.mock.calls[0][1]).toBe(testKey);
+        }
+    });
+
+    it.each(types)("does not store a bad key to the cache", async ({ type, shouldCache }) => {
+        const getCrossSigningKey = jest.fn().mockResolvedValue(badKey);
+        const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
+        const info = new CrossSigningInfo(userId, { getCrossSigningKey }, { storeCrossSigningKeyCache });
+        await expect(info.getCrossSigningKey(type, masterKeyPub)).rejects.toThrow();
+        expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(0);
+    });
+
+    it.each(types)("does not store a value to the cache if it came from the cache", async ({ type, shouldCache }) => {
+        const getCrossSigningKey = jest.fn().mockImplementation(() => {
+            if (shouldCache) {
+                return Promise.reject(new Error("Regular callback called"));
+            } 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 },
             );
-            expect(storeCrossSigningKeyCache.mock.calls.length).toBe(0);
             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);
 
-    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);
+        },
+    );
 
-        /* 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);
 
-    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);
-    });
+            /* Also expect that the cache gets updated */
+            expect(storeCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
+        },
+    );
 });
 
 /*
@@ -219,20 +198,21 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
  * it's not possible to get one in normal execution unless you hack as we do here.
  */
 describe.each([
-    ["IndexedDBCryptoStore",
-        () => new IndexedDBCryptoStore(global.indexedDB, "tests")],
-    ["LocalStorageCryptoStore",
-        () => new IndexedDBCryptoStore(undefined, "tests")],
-    ["MemoryCryptoStore", () => {
-        const store = new IndexedDBCryptoStore(undefined, "tests");
-        // @ts-ignore set private properties
-        store._backend = new MemoryCryptoStore();
-        // @ts-ignore
-        store._backendPromise = Promise.resolve(store._backend);
-        return store;
-    }],
-])("CrossSigning > createCryptoStoreCacheCallbacks [%s]", function(name, dbFactory) {
-    let store;
+    ["IndexedDBCryptoStore", () => new IndexedDBCryptoStore(global.indexedDB, "tests")],
+    ["LocalStorageCryptoStore", () => new IndexedDBCryptoStore(undefined!, "tests")],
+    [
+        "MemoryCryptoStore",
+        () => {
+            const store = new IndexedDBCryptoStore(undefined!, "tests");
+            // @ts-ignore set private properties
+            store._backend = new MemoryCryptoStore();
+            // @ts-ignore
+            store._backendPromise = Promise.resolve(store._backend);
+            return store;
+        },
+    ],
+])("CrossSigning > createCryptoStoreCacheCallbacks [%s]", function (name, dbFactory) {
+    let store: IndexedDBCryptoStore;
 
     beforeAll(() => {
         store = dbFactory();
@@ -245,16 +225,18 @@ describe.each([
     it("should cache data to the store and retrieve it", async () => {
         await store.startup();
         const olmDevice = new OlmDevice(store);
-        const { getCrossSigningKeyCache, storeCrossSigningKeyCache } =
-              createCryptoStoreCacheCallbacks(store, olmDevice);
-        await storeCrossSigningKeyCache("self_signing", testKey);
+        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", "");
+        const nokey = await getCrossSigningKeyCache!("self", "");
         expect(nokey).toBeNull();
 
-        const key = await getCrossSigningKeyCache("self_signing", "");
-        expect(new Uint8Array(key)).toEqual(testKey);
+        const key = await getCrossSigningKeyCache!("self_signing", "");
+        expect(new Uint8Array(key!)).toEqual(testKey);
     });
 });

spec/unit/crypto/DeviceList.spec.ts

@@ -22,33 +22,29 @@ 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": {
+    failures: {},
+    device_keys: {
         "@test1:sw1v.org": {
-            "HGKAWHRVJQ": {
-                "signatures": {
+            HGKAWHRVJQ: {
+                signatures: {
                     "@test1:sw1v.org": {
                         "ed25519:HGKAWHRVJQ":
                             "8PB450fxKDn5s8IiRZ2N2t6MiueQYVRLHFEzqIi1eLdxx1w" +
                             "XEPC1/1Uz9T4gwnKlMVAKkhB5hXQA/3kjaeLABw",
                     },
                 },
-                "user_id": "@test1:sw1v.org",
-                "keys": {
-                    "ed25519:HGKAWHRVJQ":
-                        "0gI/T6C+mn1pjtvnnW2yB2l1IIBb/5ULlBXi/LXFSEQ",
-                    "curve25519:HGKAWHRVJQ":
-                        "mbIZED1dBsgIgkgzxDpxKkJmsr4hiWlGzQTvUnQe3RY",
+                user_id: "@test1:sw1v.org",
+                keys: {
+                    "ed25519:HGKAWHRVJQ": "0gI/T6C+mn1pjtvnnW2yB2l1IIBb/5ULlBXi/LXFSEQ",
+                    "curve25519:HGKAWHRVJQ": "mbIZED1dBsgIgkgzxDpxKkJmsr4hiWlGzQTvUnQe3RY",
                 },
-                "algorithms": [
-                    "m.olm.v1.curve25519-aes-sha2",
-                    "m.megolm.v1.aes-sha2",
-                ],
-                "device_id": "HGKAWHRVJQ",
-                "unsigned": {
-                    "device_display_name": "",
+                algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
+                device_id: "HGKAWHRVJQ",
+                unsigned: {
+                    device_display_name: "",
                 },
             },
         },
@@ -56,50 +52,45 @@ const signedDeviceList: IDownloadKeyResult = {
 };
 
 const signedDeviceList2: IDownloadKeyResult = {
-    "failures": {},
-    "device_keys": {
+    failures: {},
+    device_keys: {
         "@test2:sw1v.org": {
-            "QJVRHWAKGH": {
-                "signatures": {
+            QJVRHWAKGH: {
+                signatures: {
                     "@test2:sw1v.org": {
                         "ed25519:QJVRHWAKGH":
                             "w1xxdLe1iIqzEFHLRVYQeuiM6t2N2ZRiI8s5nDKxf054BP8" +
                             "1CPEX/AQXh5BhkKAVMlKnwg4T9zU1/wBALeajk3",
                     },
                 },
-                "user_id": "@test2:sw1v.org",
-                "keys": {
-                    "ed25519:QJVRHWAKGH":
-                        "Ig0/C6T+bBII1l2By2Wnnvtjp1nm/iXBlLU5/QESFXL",
-                    "curve25519:QJVRHWAKGH":
-                        "YR3eQnUvTQzGlWih4rsmJkKxpDxzgkgIgsBd1DEZIbm",
+                user_id: "@test2:sw1v.org",
+                keys: {
+                    "ed25519:QJVRHWAKGH": "Ig0/C6T+bBII1l2By2Wnnvtjp1nm/iXBlLU5/QESFXL",
+                    "curve25519:QJVRHWAKGH": "YR3eQnUvTQzGlWih4rsmJkKxpDxzgkgIgsBd1DEZIbm",
                 },
-                "algorithms": [
-                    "m.olm.v1.curve25519-aes-sha2",
-                    "m.megolm.v1.aes-sha2",
-                ],
-                "device_id": "QJVRHWAKGH",
-                "unsigned": {
-                    "device_display_name": "",
+                algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
+                device_id: "QJVRHWAKGH",
+                unsigned: {
+                    device_display_name: "",
                 },
             },
         },
     },
 };
 
-describe('DeviceList', function() {
-    let downloadSpy;
-    let cryptoStore;
-    let deviceLists = [];
+describe("DeviceList", function () {
+    let downloadSpy: jest.Mock;
+    let cryptoStore: CryptoStore;
+    let deviceLists: DeviceList[] = [];
 
-    beforeEach(function() {
+    beforeEach(function () {
         deviceLists = [];
 
         downloadSpy = jest.fn();
         cryptoStore = new MemoryCryptoStore();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         for (const dl of deviceLists) {
             dl.stop();
         }
@@ -108,94 +99,96 @@ describe('DeviceList', function() {
     function createTestDeviceList(keyDownloadChunkSize = 250) {
         const baseApis = {
             downloadKeysForUsers: downloadSpy,
-            getUserId: () => '@test1:sw1v.org',
-            deviceId: 'HGKAWHRVJQ',
+            getUserId: () => "@test1:sw1v.org",
+            deviceId: "HGKAWHRVJQ",
         } as unknown as MatrixClient;
         const mockOlm = {
-            verifySignature: function(key, message, signature) {},
+            verifySignature: function (key: string, message: string, signature: string) {},
         } as unknown as OlmDevice;
         const dl = new DeviceList(baseApis, cryptoStore, mockOlm, keyDownloadChunkSize);
         deviceLists.push(dl);
         return dl;
     }
 
-    it("should successfully download and store device keys", function() {
+    it("should successfully download and store device keys", function () {
         const dl = createTestDeviceList();
 
-        dl.startTrackingDeviceList('@test1:sw1v.org');
+        dl.startTrackingDeviceList("@test1:sw1v.org");
 
         const queryDefer1 = utils.defer<IDownloadKeyResult>();
         downloadSpy.mockReturnValue(queryDefer1.promise);
 
         const prom1 = dl.refreshOutdatedDeviceLists();
-        expect(downloadSpy).toHaveBeenCalledWith(['@test1:sw1v.org'], {});
+        expect(downloadSpy).toHaveBeenCalledWith(["@test1:sw1v.org"], {});
         queryDefer1.resolve(utils.deepCopy(signedDeviceList));
 
         return prom1.then(() => {
-            const storedKeys = dl.getRawStoredDevicesForUser('@test1:sw1v.org');
-            expect(Object.keys(storedKeys)).toEqual(['HGKAWHRVJQ']);
+            const storedKeys = dl.getRawStoredDevicesForUser("@test1:sw1v.org");
+            expect(Object.keys(storedKeys)).toEqual(["HGKAWHRVJQ"]);
             dl.stop();
         });
     });
 
-    it("should have an outdated devicelist on an invalidation while an " +
-       "update is in progress", function() {
+    it("should have an outdated devicelist on an invalidation while an " + "update is in progress", function () {
         const dl = createTestDeviceList();
 
-        dl.startTrackingDeviceList('@test1:sw1v.org');
+        dl.startTrackingDeviceList("@test1:sw1v.org");
 
         const queryDefer1 = utils.defer<IDownloadKeyResult>();
         downloadSpy.mockReturnValue(queryDefer1.promise);
 
         const prom1 = dl.refreshOutdatedDeviceLists();
-        expect(downloadSpy).toHaveBeenCalledWith(['@test1:sw1v.org'], {});
+        expect(downloadSpy).toHaveBeenCalledWith(["@test1:sw1v.org"], {});
         downloadSpy.mockReset();
 
         // outdated notif arrives while the request is in flight.
         const queryDefer2 = utils.defer();
         downloadSpy.mockReturnValue(queryDefer2.promise);
 
-        dl.invalidateUserDeviceList('@test1:sw1v.org');
+        dl.invalidateUserDeviceList("@test1:sw1v.org");
         dl.refreshOutdatedDeviceLists();
 
-        dl.saveIfDirty().then(() => {
-            // the first request completes
-            queryDefer1.resolve({
-                failures: {},
-                device_keys: {
-                    '@test1:sw1v.org': {},
-                },
+        dl.saveIfDirty()
+            .then(() => {
+                // the first request completes
+                queryDefer1.resolve({
+                    failures: {},
+                    device_keys: {
+                        "@test1:sw1v.org": {},
+                    },
+                });
+                return prom1;
+            })
+            .then(() => {
+                // uh-oh; user restarts before second request completes. The new instance
+                // should know we never got a complete device list.
+                logger.log("Creating new devicelist to simulate app reload");
+                downloadSpy.mockReset();
+                const dl2 = createTestDeviceList();
+                const queryDefer3 = utils.defer<IDownloadKeyResult>();
+                downloadSpy.mockReturnValue(queryDefer3.promise);
+
+                const prom3 = dl2.refreshOutdatedDeviceLists();
+                expect(downloadSpy).toHaveBeenCalledWith(["@test1:sw1v.org"], {});
+                dl2.stop();
+
+                queryDefer3.resolve(utils.deepCopy(signedDeviceList));
+
+                // allow promise chain to complete
+                return prom3;
+            })
+            .then(() => {
+                const storedKeys = dl.getRawStoredDevicesForUser("@test1:sw1v.org");
+                expect(Object.keys(storedKeys)).toEqual(["HGKAWHRVJQ"]);
+                dl.stop();
             });
-            return prom1;
-        }).then(() => {
-            // uh-oh; user restarts before second request completes. The new instance
-            // should know we never got a complete device list.
-            logger.log("Creating new devicelist to simulate app reload");
-            downloadSpy.mockReset();
-            const dl2 = createTestDeviceList();
-            const queryDefer3 = utils.defer<IDownloadKeyResult>();
-            downloadSpy.mockReturnValue(queryDefer3.promise);
-
-            const prom3 = dl2.refreshOutdatedDeviceLists();
-            expect(downloadSpy).toHaveBeenCalledWith(['@test1:sw1v.org'], {});
-            dl2.stop();
-
-            queryDefer3.resolve(utils.deepCopy(signedDeviceList));
-
-            // allow promise chain to complete
-            return prom3;
-        }).then(() => {
-            const storedKeys = dl.getRawStoredDevicesForUser('@test1:sw1v.org');
-            expect(Object.keys(storedKeys)).toEqual(['HGKAWHRVJQ']);
-            dl.stop();
-        });
     });
 
-    it("should download device keys in batches", function() {
+    it("should download device keys in batches", function () {
         const dl = createTestDeviceList(1);
 
-        dl.startTrackingDeviceList('@test1:sw1v.org');
-        dl.startTrackingDeviceList('@test2:sw1v.org');
+        dl.startTrackingDeviceList("@test1:sw1v.org");
+        dl.startTrackingDeviceList("@test2:sw1v.org");
 
         const queryDefer1 = utils.defer<IDownloadKeyResult>();
         downloadSpy.mockReturnValueOnce(queryDefer1.promise);
@@ -204,16 +197,16 @@ describe('DeviceList', function() {
 
         const prom1 = dl.refreshOutdatedDeviceLists();
         expect(downloadSpy).toBeCalledTimes(2);
-        expect(downloadSpy).toHaveBeenNthCalledWith(1, ['@test1:sw1v.org'], {});
-        expect(downloadSpy).toHaveBeenNthCalledWith(2, ['@test2:sw1v.org'], {});
+        expect(downloadSpy).toHaveBeenNthCalledWith(1, ["@test1:sw1v.org"], {});
+        expect(downloadSpy).toHaveBeenNthCalledWith(2, ["@test2:sw1v.org"], {});
         queryDefer1.resolve(utils.deepCopy(signedDeviceList));
         queryDefer2.resolve(utils.deepCopy(signedDeviceList2));
 
         return prom1.then(() => {
-            const storedKeys1 = dl.getRawStoredDevicesForUser('@test1:sw1v.org');
-            expect(Object.keys(storedKeys1)).toEqual(['HGKAWHRVJQ']);
-            const storedKeys2 = dl.getRawStoredDevicesForUser('@test2:sw1v.org');
-            expect(Object.keys(storedKeys2)).toEqual(['QJVRHWAKGH']);
+            const storedKeys1 = dl.getRawStoredDevicesForUser("@test1:sw1v.org");
+            expect(Object.keys(storedKeys1)).toEqual(["HGKAWHRVJQ"]);
+            const storedKeys2 = dl.getRawStoredDevicesForUser("@test2:sw1v.org");
+            expect(Object.keys(storedKeys2)).toEqual(["QJVRHWAKGH"]);
             dl.stop();
         });
     });

spec/unit/crypto/algorithms/megolm.spec.js

@@ -1,838 +0,0 @@
-import '../../../olm-loader';
-import * as algorithms from "../../../../src/crypto/algorithms";
-import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
-import { MockStorageApi } from "../../../MockStorageApi";
-import * as testUtils from "../../../test-utils/test-utils";
-import { OlmDevice } from "../../../../src/crypto/OlmDevice";
-import { Crypto } from "../../../../src/crypto";
-import { logger } from "../../../../src/logger";
-import { MatrixEvent } from "../../../../src/models/event";
-import { TestClient } from "../../../TestClient";
-import { Room } from "../../../../src/models/room";
-import * as olmlib from "../../../../src/crypto/olmlib";
-
-const MegolmDecryption = algorithms.DECRYPTION_CLASSES['m.megolm.v1.aes-sha2'];
-const MegolmEncryption = algorithms.ENCRYPTION_CLASSES['m.megolm.v1.aes-sha2'];
-
-const ROOM_ID = '!ROOM:ID';
-
-const Olm = global.Olm;
-
-describe("MegolmDecryption", function() {
-    if (!global.Olm) {
-        logger.warn('Not running megolm unit tests: libolm not present');
-        return;
-    }
-
-    beforeAll(function() {
-        return Olm.init();
-    });
-
-    let megolmDecryption;
-    let mockOlmLib;
-    let mockCrypto;
-    let mockBaseApis;
-
-    beforeEach(async function() {
-        mockCrypto = testUtils.mock(Crypto, 'Crypto');
-        mockBaseApis = {};
-
-        const mockStorage = new MockStorageApi();
-        const cryptoStore = new MemoryCryptoStore(mockStorage);
-
-        const olmDevice = new OlmDevice(cryptoStore);
-
-        megolmDecryption = new MegolmDecryption({
-            userId: '@user:id',
-            crypto: mockCrypto,
-            olmDevice: olmDevice,
-            baseApis: mockBaseApis,
-            roomId: ROOM_ID,
-        });
-
-        // we stub out the olm encryption bits
-        mockOlmLib = {};
-        mockOlmLib.ensureOlmSessionsForDevices = jest.fn();
-        mockOlmLib.encryptMessageForDevice =
-            jest.fn().mockResolvedValue(undefined);
-        megolmDecryption.olmlib = mockOlmLib;
-    });
-
-    describe('receives some keys:', function() {
-        let groupSession;
-        beforeEach(async function() {
-            groupSession = new global.Olm.OutboundGroupSession();
-            groupSession.create();
-
-            // construct a fake decrypted key event via the use of a mocked
-            // 'crypto' implementation.
-            const event = new MatrixEvent({
-                type: 'm.room.encrypted',
-            });
-            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",
-            };
-
-            const mockCrypto = {
-                decryptEvent: function() {
-                    return Promise.resolve(decryptedData);
-                },
-            };
-
-            await event.attemptDecryption(mockCrypto).then(() => {
-                megolmDecryption.onRoomKeyEvent(event);
-            });
-        });
-
-        it('can decrypt an event', function() {
-            const event = new MatrixEvent({
-                type: 'm.room.encrypted',
-                room_id: ROOM_ID,
-                content: {
-                    algorithm: 'm.megolm.v1.aes-sha2',
-                    sender_key: "SENDER_CURVE25519",
-                    session_id: groupSession.session_id(),
-                    ciphertext: groupSession.encrypt(JSON.stringify({
-                        room_id: ROOM_ID,
-                        content: 'testytest',
-                    })),
-                },
-            });
-
-            return megolmDecryption.decryptEvent(event).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-            });
-        });
-
-        it('can respond to a key request event', function() {
-            const keyRequest = {
-                userId: '@alice:foo',
-                deviceId: 'alidevice',
-                requestBody: {
-                    room_id: ROOM_ID,
-                    sender_key: "SENDER_CURVE25519",
-                    session_id: groupSession.session_id(),
-                },
-            };
-
-            return megolmDecryption.hasKeysForKeyRequest(
-                keyRequest,
-            ).then((hasKeys) => {
-                expect(hasKeys).toBe(true);
-
-                // set up some pre-conditions for the share call
-                const deviceInfo = {};
-                mockCrypto.getStoredDevice.mockReturnValue(deviceInfo);
-
-                mockOlmLib.ensureOlmSessionsForDevices.mockResolvedValue({
-                    '@alice:foo': { 'alidevice': {
-                        sessionId: 'alisession',
-                    } },
-                });
-
-                const awaitEncryptForDevice = new Promise((res, rej) => {
-                    mockOlmLib.encryptMessageForDevice.mockImplementation(() => {
-                        res();
-                        return Promise.resolve();
-                    });
-                });
-
-                mockBaseApis.sendToDevice = jest.fn();
-
-                // do the share
-                megolmDecryption.shareKeysWithDevice(keyRequest);
-
-                // it's asynchronous, so we have to wait a bit
-                return awaitEncryptForDevice;
-            }).then(() => {
-                // check that it called encryptMessageForDevice with
-                // appropriate args.
-                expect(mockOlmLib.encryptMessageForDevice).toBeCalledTimes(1);
-
-                const call = mockOlmLib.encryptMessageForDevice.mock.calls[0];
-                const payload = call[6];
-
-                expect(payload.type).toEqual("m.forwarded_room_key");
-                expect(payload.content).toMatchObject({
-                    sender_key: "SENDER_CURVE25519",
-                    sender_claimed_ed25519_key: "SENDER_ED25519",
-                    session_id: groupSession.session_id(),
-                    chain_index: 0,
-                    forwarding_curve25519_key_chain: [],
-                });
-                expect(payload.content.session_key).toBeDefined();
-            });
-        });
-
-        it("can detect replay attacks", function() {
-            // trying to decrypt two different messages (marked by different
-            // event IDs or timestamps) using the same (sender key, session id,
-            // message index) triple should result in an exception being thrown
-            // as it should be detected as a replay attack.
-            const sessionId = groupSession.session_id();
-            const cipherText = groupSession.encrypt(JSON.stringify({
-                room_id: ROOM_ID,
-                content: 'testytest',
-            }));
-            const event1 = new MatrixEvent({
-                type: 'm.room.encrypted',
-                room_id: ROOM_ID,
-                content: {
-                    algorithm: 'm.megolm.v1.aes-sha2',
-                    sender_key: "SENDER_CURVE25519",
-                    session_id: sessionId,
-                    ciphertext: cipherText,
-                },
-                event_id: "$event1",
-                origin_server_ts: 1507753886000,
-            });
-
-            const successHandler = jest.fn();
-            const failureHandler = jest.fn((err) => {
-                expect(err.toString()).toMatch(
-                    /Duplicate message index, possible replay attack/,
-                );
-            });
-
-            return megolmDecryption.decryptEvent(event1).then((res) => {
-                const event2 = new MatrixEvent({
-                    type: 'm.room.encrypted',
-                    room_id: ROOM_ID,
-                    content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
-                        sender_key: "SENDER_CURVE25519",
-                        session_id: sessionId,
-                        ciphertext: cipherText,
-                    },
-                    event_id: "$event2",
-                    origin_server_ts: 1507754149000,
-                });
-
-                return megolmDecryption.decryptEvent(event2);
-            }).then(
-                successHandler,
-                failureHandler,
-            ).then(() => {
-                expect(successHandler).not.toHaveBeenCalled();
-                expect(failureHandler).toHaveBeenCalled();
-            });
-        });
-
-        it("allows re-decryption of the same event", function() {
-            // in contrast with the previous test, if the event ID and
-            // timestamp are the same, then it should not be considered a
-            // replay attack
-            const sessionId = groupSession.session_id();
-            const cipherText = groupSession.encrypt(JSON.stringify({
-                room_id: ROOM_ID,
-                content: 'testytest',
-            }));
-            const event = new MatrixEvent({
-                type: 'm.room.encrypted',
-                room_id: ROOM_ID,
-                content: {
-                    algorithm: 'm.megolm.v1.aes-sha2',
-                    sender_key: "SENDER_CURVE25519",
-                    session_id: sessionId,
-                    ciphertext: cipherText,
-                },
-                event_id: "$event1",
-                origin_server_ts: 1507753886000,
-            });
-
-            return megolmDecryption.decryptEvent(event).then((res) => {
-                return megolmDecryption.decryptEvent(event);
-                // test is successful if no exception is thrown
-            });
-        });
-
-        describe("session reuse and key reshares", () => {
-            const rotationPeriodMs = 999 * 24 * 60 * 60 * 1000; // 999 days, so we don't have to deal with it
-
-            let megolmEncryption;
-            let aliceDeviceInfo;
-            let mockRoom;
-            let olmDevice;
-
-            beforeEach(async () => {
-                mockCrypto.backupManager = {
-                    backupGroupSession: () => {},
-                };
-                const mockStorage = new MockStorageApi();
-                const cryptoStore = new MemoryCryptoStore(mockStorage);
-
-                olmDevice = new OlmDevice(cryptoStore);
-                olmDevice.verifySignature = jest.fn();
-                await olmDevice.init();
-
-                mockBaseApis.claimOneTimeKeys = jest.fn().mockReturnValue(Promise.resolve({
-                    one_time_keys: {
-                        '@alice:home.server': {
-                            aliceDevice: {
-                                'signed_curve25519:flooble': {
-                                    key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
-                                    signatures: {
-                                        '@alice:home.server': {
-                                            'ed25519:aliceDevice': 'totally valid',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                }));
-                mockBaseApis.sendToDevice = jest.fn().mockResolvedValue(undefined);
-
-                aliceDeviceInfo = {
-                    deviceId: 'aliceDevice',
-                    isBlocked: jest.fn().mockReturnValue(false),
-                    isUnverified: jest.fn().mockReturnValue(false),
-                    getIdentityKey: jest.fn().mockReturnValue(
-                        'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
-                    ),
-                    getFingerprint: jest.fn().mockReturnValue(''),
-                };
-
-                mockCrypto.downloadKeys.mockReturnValue(Promise.resolve({
-                    '@alice:home.server': {
-                        aliceDevice: aliceDeviceInfo,
-                    },
-                }));
-
-                mockCrypto.checkDeviceTrust.mockReturnValue({
-                    isVerified: () => false,
-                });
-
-                megolmEncryption = new MegolmEncryption({
-                    userId: '@user:id',
-                    crypto: mockCrypto,
-                    olmDevice: olmDevice,
-                    baseApis: mockBaseApis,
-                    roomId: ROOM_ID,
-                    config: {
-                        rotation_period_ms: rotationPeriodMs,
-                    },
-                });
-                mockRoom = {
-                    getEncryptionTargetMembers: jest.fn().mockReturnValue(
-                        [{ userId: "@alice:home.server" }],
-                    ),
-                    getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
-                };
-            });
-
-            it("should use larger otkTimeout when preparing to encrypt room", async () => {
-                megolmEncryption.prepareToEncrypt(mockRoom);
-                await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-                expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
-
-                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 10000,
-                );
-            });
-
-            it("should generate a new session if this one needs rotation", async () => {
-                const session = await megolmEncryption.prepareNewSession(false);
-                session.creationTime -= rotationPeriodMs + 10000; // a smidge over the rotation time
-                // Inject expired session which needs rotation
-                megolmEncryption.setupPromise = Promise.resolve(session);
-
-                const prepareNewSessionSpy = jest.spyOn(megolmEncryption, "prepareNewSession");
-                await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-                expect(prepareNewSessionSpy).toHaveBeenCalledTimes(1);
-            });
-
-            it("re-uses sessions for sequential messages", async function() {
-                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-                expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
-
-                // this should have claimed a key for alice as it's starting a new session
-                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-                );
-                expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
-                    ['@alice:home.server'], false,
-                );
-                expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
-                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-                );
-
-                mockBaseApis.claimOneTimeKeys.mockReset();
-
-                const ct2 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some more text",
-                });
-
-                // this should *not* have claimed a key as it should be using the same session
-                expect(mockBaseApis.claimOneTimeKeys).not.toHaveBeenCalled();
-
-                // likewise they should show the same session ID
-                expect(ct2.session_id).toEqual(ct1.session_id);
-            });
-
-            it("re-shares keys to devices it's already sent to", async function() {
-                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-
-                mockBaseApis.sendToDevice.mockClear();
-                await megolmEncryption.reshareKeyWithDevice(
-                    olmDevice.deviceCurve25519Key,
-                    ct1.session_id,
-                    '@alice:home.server',
-                    aliceDeviceInfo,
-                );
-
-                expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
-            });
-
-            it("does not re-share keys to devices whose keys have changed", async function() {
-                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-
-                aliceDeviceInfo.getIdentityKey = jest.fn().mockReturnValue(
-                    'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWI',
-                );
-
-                mockBaseApis.sendToDevice.mockClear();
-                await megolmEncryption.reshareKeyWithDevice(
-                    olmDevice.deviceCurve25519Key,
-                    ct1.session_id,
-                    '@alice:home.server',
-                    aliceDeviceInfo,
-                );
-
-                expect(mockBaseApis.sendToDevice).not.toHaveBeenCalled();
-            });
-        });
-    });
-
-    it("notifies devices that have been blocked", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient1 = (new TestClient(
-            "@bob:example.com", "bobdevice1",
-        )).client;
-        const bobClient2 = (new TestClient(
-            "@bob:example.com", "bobdevice2",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient1.initCrypto(),
-            bobClient2.initCrypto(),
-        ]);
-        const aliceDevice = aliceClient.crypto.olmDevice;
-        const bobDevice1 = bobClient1.crypto.olmDevice;
-        const bobDevice2 = bobClient2.crypto.olmDevice;
-
-        const encryptionCfg = {
-            "algorithm": "m.megolm.v1.aes-sha2",
-        };
-        const roomId = "!someroom";
-        const room = new Room(roomId, aliceClient, "@alice:example.com", {});
-        room.getEncryptionTargetMembers = async function() {
-            return [{ userId: "@bob:example.com" }];
-        };
-        room.setBlacklistUnverifiedDevices(true);
-        aliceClient.store.storeRoom(room);
-        await aliceClient.setRoomEncryption(roomId, encryptionCfg);
-
-        const BOB_DEVICES = {
-            bobdevice1: {
-                user_id: "@bob:example.com",
-                device_id: "bobdevice1",
-                algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                keys: {
-                    "ed25519:Dynabook": bobDevice1.deviceEd25519Key,
-                    "curve25519:Dynabook": bobDevice1.deviceCurve25519Key,
-                },
-                verified: 0,
-            },
-            bobdevice2: {
-                user_id: "@bob:example.com",
-                device_id: "bobdevice2",
-                algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                keys: {
-                    "ed25519:Dynabook": bobDevice2.deviceEd25519Key,
-                    "curve25519:Dynabook": bobDevice2.deviceCurve25519Key,
-                },
-                verified: -1,
-            },
-        };
-
-        aliceClient.crypto.deviceList.storeDevicesForUser(
-            "@bob:example.com", BOB_DEVICES,
-        );
-        aliceClient.crypto.deviceList.downloadKeys = async function(userIds) {
-            return this.getDevicesFromStore(userIds);
-        };
-
-        let run = false;
-        aliceClient.sendToDevice = async (msgtype, contentMap) => {
-            run = true;
-            expect(msgtype).toMatch(/^(org.matrix|m).room_key.withheld$/);
-            delete contentMap["@bob:example.com"].bobdevice1.session_id;
-            delete contentMap["@bob:example.com"].bobdevice2.session_id;
-            expect(contentMap).toStrictEqual({
-                '@bob:example.com': {
-                    bobdevice1: {
-                        algorithm: "m.megolm.v1.aes-sha2",
-                        room_id: roomId,
-                        code: 'm.unverified',
-                        reason:
-                        'The sender has disabled encrypting to unverified devices.',
-                        sender_key: aliceDevice.deviceCurve25519Key,
-                    },
-                    bobdevice2: {
-                        algorithm: "m.megolm.v1.aes-sha2",
-                        room_id: roomId,
-                        code: 'm.blacklisted',
-                        reason: 'The sender has blocked you.',
-                        sender_key: aliceDevice.deviceCurve25519Key,
-                    },
-                },
-            });
-        };
-
-        const event = new MatrixEvent({
-            type: "m.room.message",
-            sender: "@alice:example.com",
-            room_id: roomId,
-            event_id: "$event",
-            content: {
-                msgtype: "m.text",
-                body: "secret",
-            },
-        });
-        await aliceClient.crypto.encryptEvent(event, room);
-
-        expect(run).toBe(true);
-
-        aliceClient.stopClient();
-        bobClient1.stopClient();
-        bobClient2.stopClient();
-    });
-
-    it("notifies devices when unable to create olm session", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
-        const aliceDevice = aliceClient.crypto.olmDevice;
-        const bobDevice = bobClient.crypto.olmDevice;
-
-        const encryptionCfg = {
-            "algorithm": "m.megolm.v1.aes-sha2",
-        };
-        const roomId = "!someroom";
-        const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
-        const bobRoom = new Room(roomId, bobClient, "@bob:example.com", {});
-        aliceClient.store.storeRoom(aliceRoom);
-        bobClient.store.storeRoom(bobRoom);
-        await aliceClient.setRoomEncryption(roomId, encryptionCfg);
-        await bobClient.setRoomEncryption(roomId, encryptionCfg);
-
-        aliceRoom.getEncryptionTargetMembers = async () => {
-            return [
-                {
-                    userId: "@alice:example.com",
-                    membership: "join",
-                },
-                {
-                    userId: "@bob:example.com",
-                    membership: "join",
-                },
-            ];
-        };
-        const BOB_DEVICES = {
-            bobdevice: {
-                user_id: "@bob:example.com",
-                device_id: "bobdevice",
-                algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                keys: {
-                    "ed25519:bobdevice": bobDevice.deviceEd25519Key,
-                    "curve25519:bobdevice": bobDevice.deviceCurve25519Key,
-                },
-                known: true,
-                verified: 1,
-            },
-        };
-
-        aliceClient.crypto.deviceList.storeDevicesForUser(
-            "@bob:example.com", BOB_DEVICES,
-        );
-        aliceClient.crypto.deviceList.downloadKeys = async function(userIds) {
-            return this.getDevicesFromStore(userIds);
-        };
-
-        aliceClient.claimOneTimeKeys = async () => {
-            // Bob has no one-time keys
-            return {
-                one_time_keys: {},
-            };
-        };
-
-        const sendPromise = new Promise((resolve, reject) => {
-            aliceClient.sendToDevice = async (msgtype, contentMap) => {
-                expect(msgtype).toMatch(/^(org.matrix|m).room_key.withheld$/);
-                expect(contentMap).toStrictEqual({
-                    '@bob:example.com': {
-                        bobdevice: {
-                            algorithm: "m.megolm.v1.aes-sha2",
-                            code: 'm.no_olm',
-                            reason: 'Unable to establish a secure channel.',
-                            sender_key: aliceDevice.deviceCurve25519Key,
-                        },
-                    },
-                });
-                resolve();
-            };
-        });
-
-        const event = new MatrixEvent({
-            type: "m.room.message",
-            sender: "@alice:example.com",
-            room_id: roomId,
-            event_id: "$event",
-            content: {},
-        });
-        await aliceClient.crypto.encryptEvent(event, aliceRoom);
-        await sendPromise;
-        aliceClient.stopClient();
-        bobClient.stopClient();
-    });
-
-    it("throws an error describing why it doesn't have a key", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
-        const bobDevice = bobClient.crypto.olmDevice;
-
-        const roomId = "!someroom";
-
-        aliceClient.crypto.onToDeviceEvent(new MatrixEvent({
-            type: "org.matrix.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id1",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.blacklisted",
-                reason: "You have been blocked",
-            },
-        }));
-
-        await expect(aliceClient.crypto.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id1",
-            },
-        }))).rejects.toThrow("The sender has blocked you.");
-
-        aliceClient.crypto.onToDeviceEvent(new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id2",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.blacklisted",
-                reason: "You have been blocked",
-            },
-        }));
-
-        await expect(aliceClient.crypto.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id2",
-            },
-        }))).rejects.toThrow("The sender has blocked you.");
-        aliceClient.stopClient();
-        bobClient.stopClient();
-    });
-
-    it("throws an error describing the lack of an olm session", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
-        aliceClient.crypto.downloadKeys = async () => {};
-        const bobDevice = bobClient.crypto.olmDevice;
-
-        const roomId = "!someroom";
-
-        const now = Date.now();
-
-        aliceClient.crypto.onToDeviceEvent(new MatrixEvent({
-            type: "org.matrix.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id1",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.no_olm",
-                reason: "Unable to establish a secure channel.",
-            },
-        }));
-
-        await new Promise((resolve) => {
-            setTimeout(resolve, 100);
-        });
-
-        await expect(aliceClient.crypto.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id1",
-            },
-            origin_server_ts: now,
-        }))).rejects.toThrow("The sender was unable to establish a secure channel.");
-
-        aliceClient.crypto.onToDeviceEvent(new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id2",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.no_olm",
-                reason: "Unable to establish a secure channel.",
-            },
-        }));
-
-        await new Promise((resolve) => {
-            setTimeout(resolve, 100);
-        });
-
-        await expect(aliceClient.crypto.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id2",
-            },
-            origin_server_ts: now,
-        }))).rejects.toThrow("The sender was unable to establish a secure channel.");
-        aliceClient.stopClient();
-        bobClient.stopClient();
-    });
-
-    it("throws an error to indicate a wedged olm session", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
-        const bobDevice = bobClient.crypto.olmDevice;
-        aliceClient.crypto.downloadKeys = async () => {};
-
-        const roomId = "!someroom";
-
-        const now = Date.now();
-
-        // pretend we got an event that we can't decrypt
-        aliceClient.crypto.onToDeviceEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            content: {
-                msgtype: "m.bad.encrypted",
-                algorithm: "m.megolm.v1.aes-sha2",
-                session_id: "session_id",
-                sender_key: bobDevice.deviceCurve25519Key,
-            },
-        }));
-
-        await new Promise((resolve) => {
-            setTimeout(resolve, 100);
-        });
-
-        await expect(aliceClient.crypto.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id",
-            },
-            origin_server_ts: now,
-        }))).rejects.toThrow("The secure channel with the sender was corrupted.");
-        aliceClient.stopClient();
-        bobClient.stopClient();
-    });
-});

spec/unit/crypto/algorithms/olm.spec.ts

@@ -1,6 +1,6 @@
 /*
 Copyright 2018,2019 New Vector Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
+Copyright 2019, 2022 The Matrix.org Foundation C.I.C.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -15,94 +15,94 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../../olm-loader';
+import { MockedObject } from "jest-mock";
+
+import "../../../olm-loader";
 import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
-import { MockStorageApi } from "../../../MockStorageApi";
 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 mockStorage = new MockStorageApi();
-    const cryptoStore = new MemoryCryptoStore(mockStorage);
+    const cryptoStore = new MemoryCryptoStore();
     const olmDevice = new OlmDevice(cryptoStore);
     return olmDevice;
 }
 
-async function setupSession(initiator, opponent) {
+async function setupSession(initiator: OlmDevice, opponent: OlmDevice) {
     await opponent.generateOneTimeKeys(1);
     const keys = await opponent.getOneTimeKeys();
-    const firstKey = Object.values(keys['curve25519'])[0];
+    const firstKey = Object.values(keys["curve25519"])[0];
 
-    const sid = await initiator.createOutboundSession(
-        opponent.deviceCurve25519Key, firstKey,
-    );
+    const sid = await initiator.createOutboundSession(opponent.deviceCurve25519Key!, firstKey);
     return sid;
 }
 
-describe("OlmDevice", function() {
+function alwaysSucceed<T>(promise: Promise<T>): Promise<T | void> {
+    // swallow any exception thrown by a promise, so that
+    // Promise.all doesn't abort
+    return promise.catch(() => {});
+}
+
+describe("OlmDevice", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm unit tests: libolm not present');
+        logger.warn("Not running megolm unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return global.Olm.init();
     });
 
-    let aliceOlmDevice;
-    let bobOlmDevice;
+    let aliceOlmDevice: OlmDevice;
+    let bobOlmDevice: OlmDevice;
 
-    beforeEach(async function() {
+    beforeEach(async function () {
         aliceOlmDevice = makeOlmDevice();
         bobOlmDevice = makeOlmDevice();
         await aliceOlmDevice.init();
         await bobOlmDevice.init();
     });
 
-    describe('olm', function() {
-        it("can decrypt messages", async function() {
+    describe("olm", function () {
+        it("can decrypt messages", async function () {
             const sid = await setupSession(aliceOlmDevice, bobOlmDevice);
 
-            const ciphertext = await aliceOlmDevice.encryptMessage(
-                bobOlmDevice.deviceCurve25519Key,
+            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,
+                aliceOlmDevice.deviceCurve25519Key!,
                 ciphertext.type,
                 ciphertext.body,
             );
-            expect(result.payload).toEqual(
-                "The olm or proteus is an aquatic salamander in the family Proteidae",
-            );
+            expect(result.payload).toEqual("The olm or proteus is an aquatic salamander in the family Proteidae");
         });
 
-        it('exports picked account and olm sessions', async function() {
+        it("exports picked account and olm sessions", async function () {
             const sessionId = await setupSession(aliceOlmDevice, bobOlmDevice);
 
             const exported = await bobOlmDevice.export();
             // At this moment only Alice (the “initiator” in setupSession) has a session
             expect(exported.sessions).toEqual([]);
 
-            const MESSAGE = (
-                "The olm or proteus is an aquatic salamander"
-                + " in the family Proteidae"
-            );
-            const ciphertext = await aliceOlmDevice.encryptMessage(
-                bobOlmDevice.deviceCurve25519Key,
+            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,
+                aliceOlmDevice.deviceCurve25519Key!,
                 ciphertext.type,
                 ciphertext.body,
             );
@@ -112,22 +112,19 @@ describe("OlmDevice", function() {
             // this time we expect Bob to have a session to export
             expect(exportedAgain.sessions).toHaveLength(1);
 
-            const MESSAGE_2 = (
-                "In contrast to most amphibians,"
-                + " the olm is entirely aquatic"
-            );
-            const ciphertext2 = await aliceOlmDevice.encryptMessage(
-                bobOlmDevice.deviceCurve25519Key,
+            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,
+                aliceOlmDevice.deviceCurve25519Key!,
                 decrypted.session_id,
                 ciphertext2.type,
                 ciphertext2.body,
@@ -135,7 +132,7 @@ describe("OlmDevice", function() {
             expect(decrypted2).toEqual(MESSAGE_2);
         });
 
-        it("creates only one session at a time", async function() {
+        it("creates only one session at a time", async function () {
             // if we call ensureOlmSessionsForDevices multiple times, it should
             // only try to create one session at a time, even if the server is
             // slow
@@ -148,30 +145,24 @@ describe("OlmDevice", function() {
                         setTimeout(reject, 500);
                     });
                 },
-            };
+            } as unknown as MockedObject<MatrixClient>;
             const devicesByUser = {
                 "@bob:example.com": [
-                    DeviceInfo.fromStorage({
-                        keys: {
-                            "curve25519:ABCDEFG": "akey",
+                    DeviceInfo.fromStorage(
+                        {
+                            keys: {
+                                "curve25519:ABCDEFG": "akey",
+                            },
                         },
-                    }, "ABCDEFG"),
+                        "ABCDEFG",
+                    ),
                 ],
             };
-            function alwaysSucceed(promise) {
-                // swallow any exception thrown by a promise, so that
-                // Promise.all doesn't abort
-                return promise.catch(() => {});
-            }
 
             // start two tasks that try to ensure that there's an olm session
             const promises = Promise.all([
-                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                    aliceOlmDevice, baseApis, devicesByUser,
-                )),
-                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                    aliceOlmDevice, baseApis, devicesByUser,
-                )),
+                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUser)),
+                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUser)),
             ]);
 
             await new Promise((resolve) => {
@@ -191,7 +182,7 @@ describe("OlmDevice", function() {
             expect(count).toBe(2);
         });
 
-        it("avoids deadlocks when two tasks are ensuring the same devices", async function() {
+        it("avoids deadlocks when two tasks are ensuring the same devices", async function () {
             // This test checks whether `ensureOlmSessionsForDevices` properly
             // handles multiple tasks in flight ensuring some set of devices in
             // common without deadlocks.
@@ -205,62 +196,49 @@ describe("OlmDevice", function() {
                         setTimeout(reject, 500);
                     });
                 },
-            };
+            } as unknown as MockedObject<MatrixClient>;
 
-            const deviceBobA = DeviceInfo.fromStorage({
-                keys: {
-                    "curve25519:BOB-A": "akey",
+            const deviceBobA = DeviceInfo.fromStorage(
+                {
+                    keys: {
+                        "curve25519:BOB-A": "akey",
+                    },
                 },
-            }, "BOB-A");
-            const deviceBobB = DeviceInfo.fromStorage({
-                keys: {
-                    "curve25519:BOB-B": "bkey",
+                "BOB-A",
+            );
+            const deviceBobB = DeviceInfo.fromStorage(
+                {
+                    keys: {
+                        "curve25519:BOB-B": "bkey",
+                    },
                 },
-            }, "BOB-B");
+                "BOB-B",
+            );
 
             // There's no required ordering of devices per user, so here we
             // create two different orderings so that each task reserves a
             // device the other task needs before continuing.
             const devicesByUserAB = {
-                "@bob:example.com": [
-                    deviceBobA,
-                    deviceBobB,
-                ],
+                "@bob:example.com": [deviceBobA, deviceBobB],
             };
             const devicesByUserBA = {
-                "@bob:example.com": [
-                    deviceBobB,
-                    deviceBobA,
-                ],
+                "@bob:example.com": [deviceBobB, deviceBobA],
             };
 
-            function alwaysSucceed(promise) {
-                // swallow any exception thrown by a promise, so that
-                // Promise.all doesn't abort
-                return promise.catch(() => {});
-            }
-
-            const task1 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                aliceOlmDevice, baseApis, devicesByUserAB,
-            ));
+            const task1 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUserAB));
 
             // After a single tick through the first task, it should have
             // claimed ownership of all devices to avoid deadlocking others.
             expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);
 
-            const task2 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                aliceOlmDevice, baseApis, devicesByUserBA,
-            ));
+            const task2 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUserBA));
 
             // The second task should not have changed the ownership count, as
             // it's waiting on the first task.
             expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);
 
             // Track the tasks, but don't await them yet.
-            const promises = Promise.all([
-                task1,
-                task2,
-            ]);
+            const promises = Promise.all([task1, task2]);
 
             await new Promise((resolve) => {
                 setTimeout(resolve, 200);

spec/unit/crypto/backup.spec.ts

@@ -15,9 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MockedObject } from "jest-mock";
-
-import '../../olm-loader';
+import "../../olm-loader";
 import { logger } from "../../../src/logger";
 import * as olmlib from "../../../src/crypto/olmlib";
 import { MatrixClient } from "../../../src/client";
@@ -30,27 +28,31 @@ import { Crypto } from "../../../src/crypto";
 import { resetCrossSigningKeys } from "./crypto-utils";
 import { BackupManager } from "../../../src/crypto/backup";
 import { StubStore } from "../../../src/store/stub";
-import { IAbortablePromise, MatrixScheduler } from '../../../src';
+import { IndexedDBCryptoStore, MatrixScheduler } from "../../../src";
+import { CryptoStore } from "../../../src/crypto/store/base";
+import { MegolmDecryption as MegolmDecryptionClass } from "../../../src/crypto/algorithms/megolm";
+import { IKeyBackupInfo } from "../../../src/crypto/keybackup";
 
 const Olm = global.Olm;
 
-const MegolmDecryption = algorithms.DECRYPTION_CLASSES['m.megolm.v1.aes-sha2'];
+const MegolmDecryption = algorithms.DECRYPTION_CLASSES.get("m.megolm.v1.aes-sha2")!;
 
-const ROOM_ID = '!ROOM:ID';
+const ROOM_ID = "!ROOM:ID";
 
-const SESSION_ID = 'o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc';
+const SESSION_ID = "o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc";
 const ENCRYPTED_EVENT = new MatrixEvent({
-    type: 'm.room.encrypted',
-    room_id: '!ROOM:ID',
+    type: "m.room.encrypted",
+    room_id: "!ROOM:ID",
     content: {
-        algorithm: 'm.megolm.v1.aes-sha2',
-        sender_key: 'SENDER_CURVE25519',
+        algorithm: "m.megolm.v1.aes-sha2",
+        sender_key: "SENDER_CURVE25519",
         session_id: SESSION_ID,
-        ciphertext: 'AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N'
-            + 'CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl'
-            + 'mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs',
+        ciphertext:
+            "AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N" +
+            "CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl" +
+            "mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs",
     },
-    event_id: '$event1',
+    event_id: "$event1",
     origin_server_ts: 1507753886000,
 });
 
@@ -59,19 +61,20 @@ const CURVE25519_KEY_BACKUP_DATA = {
     forwarded_count: 0,
     is_verified: false,
     session_data: {
-        ciphertext: '2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw'
-            + '6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ'
-            + 'Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9'
-            + 'SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy'
-            + 'Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF'
-            + 'ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV'
-            + '4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv'
-            + 'C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe'
-            + 'Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf'
-            + 'QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy'
-            + 'iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg',
-        mac: '5lxYBHQU80M',
-        ephemeral: '/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14',
+        ciphertext:
+            "2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw" +
+            "6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ" +
+            "Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9" +
+            "SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy" +
+            "Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF" +
+            "ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV" +
+            "4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv" +
+            "C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe" +
+            "Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf" +
+            "QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy" +
+            "iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg",
+        mac: "5lxYBHQU80M",
+        ephemeral: "/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14",
     },
 };
 
@@ -80,58 +83,64 @@ const AES256_KEY_BACKUP_DATA = {
     forwarded_count: 0,
     is_verified: false,
     session_data: {
-        iv: 'b3Jqqvm5S9QdmXrzssspLQ',
-        ciphertext: 'GOOASO3E9ThogkG0zMjEduGLM3u9jHZTkS7AvNNbNj3q1znwk4OlaVKXce'
-            + '7ynofiiYIiS865VlOqrKEEXv96XzRyUpgn68e3WsicwYl96EtjIEh/iY003PG2Qd'
-            + 'EluT899Ax7PydpUHxEktbWckMppYomUR5q8x1KI1SsOQIiJaIGThmIMPANRCFiK0'
-            + 'WQj+q+dnhzx4lt9AFqU5bKov8qKnw2qGYP7/+6RmJ0Kpvs8tG6lrcNDEHtFc2r0r'
-            + 'KKubDypo0Vc8EWSwsAHdKa36ewRavpreOuE8Z9RLfY0QIR1ecXrMqW0CdGFr7H3P'
-            + 'vcjF8sjwvQAavzxEKT1WMGizSMLeKWo2mgZ5cKnwV5HGUAw596JQvKs9laG2U89K'
-            + 'YrT0sH30vi62HKzcBLcDkWkUSNYPz7UiZ1MM0L380UA+1ZOXSOmtBA9xxzzbc8Xd'
-            + 'fRimVgklGdxrxjzuNLYhL2BvVH4oPWonD9j0bvRwE6XkimdbGQA8HB7UmXXjE8WA'
-            + 'RgaDHkfzoA3g3aeQ',
-        mac: 'uR988UYgGL99jrvLLPX3V1ows+UYbktTmMxPAo2kxnU',
+        iv: "b3Jqqvm5S9QdmXrzssspLQ",
+        ciphertext:
+            "GOOASO3E9ThogkG0zMjEduGLM3u9jHZTkS7AvNNbNj3q1znwk4OlaVKXce" +
+            "7ynofiiYIiS865VlOqrKEEXv96XzRyUpgn68e3WsicwYl96EtjIEh/iY003PG2Qd" +
+            "EluT899Ax7PydpUHxEktbWckMppYomUR5q8x1KI1SsOQIiJaIGThmIMPANRCFiK0" +
+            "WQj+q+dnhzx4lt9AFqU5bKov8qKnw2qGYP7/+6RmJ0Kpvs8tG6lrcNDEHtFc2r0r" +
+            "KKubDypo0Vc8EWSwsAHdKa36ewRavpreOuE8Z9RLfY0QIR1ecXrMqW0CdGFr7H3P" +
+            "vcjF8sjwvQAavzxEKT1WMGizSMLeKWo2mgZ5cKnwV5HGUAw596JQvKs9laG2U89K" +
+            "YrT0sH30vi62HKzcBLcDkWkUSNYPz7UiZ1MM0L380UA+1ZOXSOmtBA9xxzzbc8Xd" +
+            "fRimVgklGdxrxjzuNLYhL2BvVH4oPWonD9j0bvRwE6XkimdbGQA8HB7UmXXjE8WA" +
+            "RgaDHkfzoA3g3aeQ",
+        mac: "uR988UYgGL99jrvLLPX3V1ows+UYbktTmMxPAo2kxnU",
     },
 };
 
 const CURVE25519_BACKUP_INFO = {
     algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-    version: '1',
+    version: "1",
     auth_data: {
         public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
     },
 };
 
-const AES256_BACKUP_INFO = {
+const AES256_BACKUP_INFO: IKeyBackupInfo = {
     algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
-    version: '1',
-    auth_data: {
-        // FIXME: add iv and mac
-    },
+    version: "1",
+    auth_data: {} as IKeyBackupInfo["auth_data"],
 };
 
-const keys = {};
+const keys: Record<string, Uint8Array> = {};
 
-function getCrossSigningKey(type) {
-    return keys[type];
+function getCrossSigningKey(type: string) {
+    return Promise.resolve(keys[type]);
 }
 
-function saveCrossSigningKeys(k) {
+function saveCrossSigningKeys(k: Record<string, Uint8Array>) {
     Object.assign(keys, k);
 }
 
-function makeTestClient(cryptoStore) {
-    const scheduler = [
-        "getQueueForEvent", "queueEvent", "removeEventFromQueue",
-        "setProcessFunction",
-    ].reduce((r, k) => {r[k] = jest.fn(); return r;}, {}) as MockedObject<MatrixScheduler>;
+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();
 
-    return new MatrixClient({
+    const client = new MatrixClient({
         baseUrl: "https://my.home.server",
         idBaseUrl: "https://identity.server",
         accessToken: "my.access.token",
-        request: jest.fn(), // NOP
+        fetchFn: jest.fn(), // NOP
         store: store,
         scheduler: scheduler,
         userId: "@alice:bar",
@@ -139,86 +148,93 @@ function makeTestClient(cryptoStore) {
         cryptoStore: cryptoStore,
         cryptoCallbacks: { getCrossSigningKey, saveCrossSigningKeys },
     });
+
+    // initialising the crypto library will trigger a key upload request, which we can stub out
+    client.uploadKeysRequest = jest.fn();
+    return client;
 }
 
-describe("MegolmBackup", function() {
+describe("MegolmBackup", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn("Not running megolm backup unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return Olm.init();
     });
 
-    let olmDevice;
-    let mockOlmLib;
-    let mockCrypto;
-    let cryptoStore;
-    let megolmDecryption;
-    beforeEach(async function() {
-        mockCrypto = testUtils.mock(Crypto, 'Crypto');
+    let olmDevice: OlmDevice;
+    let mockOlmLib: typeof olmlib;
+    let mockCrypto: Crypto;
+    let cryptoStore: CryptoStore;
+    let megolmDecryption: MegolmDecryptionClass;
+    beforeEach(async function () {
+        mockCrypto = testUtils.mock(Crypto, "Crypto");
+        // @ts-ignore making mock
         mockCrypto.backupManager = testUtils.mock(BackupManager, "BackupManager");
-        mockCrypto.backupKey = new Olm.PkEncryption();
-        mockCrypto.backupKey.set_recipient_key(
-            "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-        );
-        mockCrypto.backupInfo = CURVE25519_BACKUP_INFO;
+        mockCrypto.backupManager.backupInfo = CURVE25519_BACKUP_INFO;
 
         cryptoStore = new MemoryCryptoStore();
 
         olmDevice = new OlmDevice(cryptoStore);
 
         // we stub out the olm encryption bits
-        mockOlmLib = {};
+        mockOlmLib = {} as unknown as typeof olmlib;
         mockOlmLib.ensureOlmSessionsForDevices = jest.fn();
-        mockOlmLib.encryptMessageForDevice =
-            jest.fn().mockResolvedValue(undefined);
+        mockOlmLib.encryptMessageForDevice = jest.fn().mockResolvedValue(undefined);
     });
 
-    describe("backup", function() {
-        let mockBaseApis;
+    describe("backup", function () {
+        let mockBaseApis: MatrixClient;
 
-        beforeEach(function() {
-            mockBaseApis = {};
+        beforeEach(function () {
+            mockBaseApis = {} as unknown as MatrixClient;
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                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 = global.setTimeout;
-            jest.spyOn(global, 'setTimeout').mockImplementation(function(f, n) {
-                return realSetTimeout(f, n/100);
+            jest.spyOn(global, "setTimeout").mockImplementation(function (f, n) {
+                return realSetTimeout(f!, n! / 100);
             });
         });
 
-        afterEach(function() {
-            jest.spyOn(global, 'setTimeout').mockRestore();
+        afterEach(function () {
+            jest.spyOn(global, "setTimeout").mockRestore();
         });
 
-        it('automatically calls the key back up', function() {
+        it("automatically calls the key back up", function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
 
             // construct a fake decrypted key event via the use of a mocked
             // 'crypto' implementation.
             const event = new MatrixEvent({
-                type: 'm.room.encrypted',
+                type: "m.room.encrypted",
             });
+            event.getWireType = () => "m.room.encrypted";
+            event.getWireContent = () => {
+                return {
+                    algorithm: "m.olm.v1.curve25519-aes-sha2",
+                };
+            };
             const decryptedData = {
                 clearEvent: {
-                    type: 'm.room_key',
+                    type: "m.room_key",
                     content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
+                        algorithm: "m.megolm.v1.aes-sha2",
                         room_id: ROOM_ID,
                         session_id: groupSession.session_id(),
                         session_key: groupSession.session_key(),
@@ -228,23 +244,27 @@ describe("MegolmBackup", function() {
                 claimedEd25519Key: "SENDER_ED25519",
             };
 
-            mockCrypto.decryptEvent = function() {
+            mockCrypto.decryptEvent = function () {
                 return Promise.resolve(decryptedData);
             };
-            mockCrypto.cancelRoomKeyRequest = function() {};
+            mockCrypto.cancelRoomKeyRequest = function () {};
 
+            // @ts-ignore readonly field write
             mockCrypto.backupManager = {
                 backupGroupSession: jest.fn(),
             };
 
-            return event.attemptDecryption(mockCrypto).then(() => {
-                return megolmDecryption.onRoomKeyEvent(event);
-            }).then(() => {
-                expect(mockCrypto.backupManager.backupGroupSession).toHaveBeenCalled();
-            });
+            return event
+                .attemptDecryption(mockCrypto)
+                .then(() => {
+                    return megolmDecryption.onRoomKeyEvent(event);
+                })
+                .then(() => {
+                    expect(mockCrypto.backupManager.backupGroupSession).toHaveBeenCalled();
+                });
         });
 
-        it('sends backups to the server (Curve25519 version)', function() {
+        it("sends backups to the server (Curve25519 version)", function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
             const ibGroupSession = new Olm.InboundGroupSession();
@@ -253,66 +273,64 @@ describe("MegolmBackup", function() {
             const client = makeTestClient(cryptoStore);
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
-            return client.initCrypto()
+            return client
+                .initCrypto()
                 .then(() => {
-                    return cryptoStore.doTxn(
-                        "readwrite",
-                        [cryptoStore.STORE_SESSION],
-                        (txn) => {
-                            cryptoStore.addEndToEndInboundGroupSession(
-                                "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                                groupSession.session_id(),
-                                {
-                                    forwardingCurve25519KeyChain: undefined,
-                                    keysClaimed: {
-                                        ed25519: "SENDER_ED25519",
-                                    },
-                                    room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
+                    return cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {
+                        cryptoStore.addEndToEndInboundGroupSession(
+                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                            groupSession.session_id(),
+                            {
+                                forwardingCurve25519KeyChain: undefined!,
+                                keysClaimed: {
+                                    ed25519: "SENDER_ED25519",
                                 },
-                                txn);
-                        });
+                                room_id: ROOM_ID,
+                                session: ibGroupSession.pickle(olmDevice.pickleKey),
+                            },
+                            txn,
+                        );
+                    });
                 })
                 .then(async () => {
                     await client.enableKeyBackup({
                         algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                        version: '1',
+                        version: "1",
                         auth_data: {
                             public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
                         },
                     });
                     let numCalls = 0;
                     return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function(
-                            callback, method, path, queryParams, data, opts,
-                        ) {
+                        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({}) as IAbortablePromise<any>;
+                                return Promise.resolve({});
                             }
                             expect(method).toBe("PUT");
                             expect(path).toBe("/room_keys/keys");
-                            expect(queryParams.version).toBe('1');
-                            expect(data.rooms[ROOM_ID].sessions).toBeDefined();
-                            expect(data.rooms[ROOM_ID].sessions).toHaveProperty(
+                            expect(queryParams?.version).toBe("1");
+                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
+                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
                                 groupSession.session_id(),
                             );
                             resolve();
-                            return Promise.resolve({}) as IAbortablePromise<any>;
+                            return Promise.resolve({});
                         };
-                        client.crypto.backupManager.backupGroupSession(
+                        client.crypto!.backupManager.backupGroupSession(
                             "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
                             groupSession.session_id(),
                         );
@@ -323,7 +341,7 @@ describe("MegolmBackup", function() {
                 });
         });
 
-        it('sends backups to the server (AES-256 version)', function() {
+        it("sends backups to the server (AES-256 version)", function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
             const ibGroupSession = new Olm.InboundGroupSession();
@@ -332,42 +350,42 @@ describe("MegolmBackup", function() {
             const client = makeTestClient(cryptoStore);
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
-            return client.initCrypto()
+            return client
+                .initCrypto()
                 .then(() => {
-                    return client.crypto.storeSessionBackupPrivateKey(new Uint8Array(32));
+                    return client.crypto!.storeSessionBackupPrivateKey(new Uint8Array(32));
                 })
                 .then(() => {
-                    return cryptoStore.doTxn(
-                        "readwrite",
-                        [cryptoStore.STORE_SESSION],
-                        (txn) => {
-                            cryptoStore.addEndToEndInboundGroupSession(
-                                "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                                groupSession.session_id(),
-                                {
-                                    forwardingCurve25519KeyChain: undefined,
-                                    keysClaimed: {
-                                        ed25519: "SENDER_ED25519",
-                                    },
-                                    room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
+                    return cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {
+                        cryptoStore.addEndToEndInboundGroupSession(
+                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                            groupSession.session_id(),
+                            {
+                                forwardingCurve25519KeyChain: undefined!,
+                                keysClaimed: {
+                                    ed25519: "SENDER_ED25519",
                                 },
-                                txn);
-                        });
+                                room_id: ROOM_ID,
+                                session: ibGroupSession.pickle(olmDevice.pickleKey),
+                            },
+                            txn,
+                        );
+                    });
                 })
                 .then(async () => {
                     await client.enableKeyBackup({
                         algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
-                        version: '1',
+                        version: "1",
                         auth_data: {
                             iv: "PsCAtR7gMc4xBd9YS3A9Ow",
                             mac: "ZSDsTFEZK7QzlauCLMleUcX96GQZZM7UNtk4sripSqQ",
@@ -375,27 +393,25 @@ describe("MegolmBackup", function() {
                     });
                     let numCalls = 0;
                     return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function(
-                            callback, method, path, queryParams, data, opts,
-                        ) {
+                        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({}) as IAbortablePromise<any>;
+                                return Promise.resolve({});
                             }
                             expect(method).toBe("PUT");
                             expect(path).toBe("/room_keys/keys");
-                            expect(queryParams.version).toBe('1');
-                            expect(data.rooms[ROOM_ID].sessions).toBeDefined();
-                            expect(data.rooms[ROOM_ID].sessions).toHaveProperty(
+                            expect(queryParams?.version).toBe("1");
+                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
+                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
                                 groupSession.session_id(),
                             );
                             resolve();
-                            return Promise.resolve({}) as IAbortablePromise<any>;
+                            return Promise.resolve({});
                         };
-                        client.crypto.backupManager.backupGroupSession(
+                        client.crypto!.backupManager.backupGroupSession(
                             "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
                             groupSession.session_id(),
                         );
@@ -406,7 +422,7 @@ describe("MegolmBackup", function() {
                 });
         });
 
-        it('signs backups with the cross-signing master key', async function() {
+        it("signs backups with the cross-signing master key", async function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
             const ibGroupSession = new Olm.InboundGroupSession();
@@ -415,26 +431,29 @@ describe("MegolmBackup", function() {
             const client = makeTestClient(cryptoStore);
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
             await client.initCrypto();
-            client.uploadDeviceSigningKeys = async function(e) {return {};};
-            client.uploadKeySignatures = async function(e) {return { failures: {} };};
+            client.uploadDeviceSigningKeys = async function (e) {
+                return {};
+            };
+            client.uploadKeySignatures = async function (e) {
+                return { failures: {} };
+            };
             await resetCrossSigningKeys(client);
             let numCalls = 0;
             await Promise.all([
                 new Promise<void>((resolve, reject) => {
-                    let backupInfo;
-                    client.http.authedRequest = function(
-                        callback, method, path, queryParams, data, opts,
-                    ) {
+                    let backupInfo: Record<string, any> | BodyInit | undefined;
+                    client.http.authedRequest = function (method, path, queryParams, data, opts): any {
                         ++numCalls;
                         expect(numCalls).toBeLessThanOrEqual(2);
                         if (numCalls === 1) {
@@ -443,23 +462,25 @@ describe("MegolmBackup", function() {
                             try {
                                 // make sure auth_data is signed by the master key
                                 olmlib.pkVerify(
-                                    data.auth_data, client.getCrossSigningId(), "@alice:bar",
+                                    (data as Record<string, any>).auth_data,
+                                    client.getCrossSigningId()!,
+                                    "@alice:bar",
                                 );
                             } catch (e) {
                                 reject(e);
-                                return Promise.resolve({}) as IAbortablePromise<any>;
+                                return Promise.resolve({});
                             }
                             backupInfo = data;
-                            return Promise.resolve({}) as IAbortablePromise<any>;
+                            return Promise.resolve({});
                         } else if (numCalls === 2) {
                             expect(method).toBe("GET");
                             expect(path).toBe("/room_keys/version");
                             resolve();
-                            return Promise.resolve(backupInfo) as IAbortablePromise<any>;
+                            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({}) as IAbortablePromise<any>;
+                            return Promise.resolve({});
                         }
                     };
                 }),
@@ -474,61 +495,59 @@ describe("MegolmBackup", function() {
             client.stopClient();
         });
 
-        it('retries when a backup fails', async function() {
+        it("retries when a backup fails", async function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
             const ibGroupSession = new Olm.InboundGroupSession();
             ibGroupSession.create(groupSession.session_key());
 
-            const scheduler = [
-                "getQueueForEvent", "queueEvent", "removeEventFromQueue",
-                "setProcessFunction",
-            ].reduce((r, k) => {r[k] = jest.fn(); return r;}, {}) as MockedObject<MatrixScheduler>;
+            const scheduler = makeTestScheduler();
             const store = new StubStore();
             const client = new MatrixClient({
                 baseUrl: "https://my.home.server",
                 idBaseUrl: "https://identity.server",
                 accessToken: "my.access.token",
-                request: jest.fn(), // NOP
+                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',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
             await client.initCrypto();
-            await cryptoStore.doTxn(
-                "readwrite",
-                [cryptoStore.STORE_SESSION],
-                (txn) => {
-                    cryptoStore.addEndToEndInboundGroupSession(
-                        "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                        groupSession.session_id(),
-                        {
-                            forwardingCurve25519KeyChain: undefined,
-                            keysClaimed: {
-                                ed25519: "SENDER_ED25519",
-                            },
-                            room_id: ROOM_ID,
-                            session: ibGroupSession.pickle(olmDevice.pickleKey),
+            await cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {
+                cryptoStore.addEndToEndInboundGroupSession(
+                    "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                    groupSession.session_id(),
+                    {
+                        forwardingCurve25519KeyChain: undefined!,
+                        keysClaimed: {
+                            ed25519: "SENDER_ED25519",
                         },
-                        txn);
-                });
+                        room_id: ROOM_ID,
+                        session: ibGroupSession.pickle(olmDevice.pickleKey),
+                    },
+                    txn,
+                );
+            });
 
             await client.enableKeyBackup({
                 algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                version: '1',
+                version: "1",
                 auth_data: {
                     public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
                 },
@@ -536,33 +555,29 @@ describe("MegolmBackup", function() {
             let numCalls = 0;
 
             await new Promise<void>((resolve, reject) => {
-                client.http.authedRequest = function(
-                    callback, method, path, queryParams, data, opts,
-                ) {
+                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({}) as IAbortablePromise<any>;
+                        return Promise.resolve({});
                     }
                     expect(method).toBe("PUT");
                     expect(path).toBe("/room_keys/keys");
-                    expect(queryParams.version).toBe('1');
-                    expect(data.rooms[ROOM_ID].sessions).toBeDefined();
-                    expect(data.rooms[ROOM_ID].sessions).toHaveProperty(
+                    expect(queryParams?.version).toBe("1");
+                    expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
+                    expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
                         groupSession.session_id(),
                     );
                     if (numCalls > 1) {
                         resolve();
-                        return Promise.resolve({}) as IAbortablePromise<any>;
+                        return Promise.resolve({});
                     } else {
-                        return Promise.reject(
-                            new Error("this is an expected failure"),
-                        ) as IAbortablePromise<any>;
+                        return Promise.reject(new Error("this is an expected failure"));
                     }
                 };
-                return client.crypto.backupManager.backupGroupSession(
+                return client.crypto!.backupManager.backupGroupSession(
                     "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
                     groupSession.session_id(),
                 );
@@ -572,66 +587,73 @@ describe("MegolmBackup", function() {
         });
     });
 
-    describe("restore", function() {
-        let client;
+    describe("restore", function () {
+        let client: MatrixClient;
 
-        beforeEach(function() {
+        beforeEach(function () {
             client = makeTestClient(cryptoStore);
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
             return client.initCrypto();
         });
 
-        afterEach(function() {
+        afterEach(function () {
             client.stopClient();
         });
 
-        it('can restore from backup (Curve25519 version)', function() {
-            client.http.authedRequest = function() {
-                return Promise.resolve(CURVE25519_KEY_BACKUP_DATA);
+        it("can restore from backup (Curve25519 version)", function () {
+            client.http.authedRequest = function () {
+                return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
             };
-            return client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                ROOM_ID,
-                SESSION_ID,
-                CURVE25519_BACKUP_INFO,
-            ).then(() => {
-                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-            }).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-                expect(res.untrusted).toBeTruthy(); // keys from Curve25519 backup are untrusted
-            });
+            return client
+                .restoreKeyBackupWithRecoveryKey(
+                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+                    ROOM_ID,
+                    SESSION_ID,
+                    CURVE25519_BACKUP_INFO,
+                )
+                .then(() => {
+                    return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
+                })
+                .then((res) => {
+                    expect(res.clearEvent.content).toEqual("testytest");
+                    expect(res.untrusted).toBeTruthy(); // keys from Curve25519 backup are untrusted
+                });
         });
 
-        it('can restore from backup (AES-256 version)', function() {
-            client.http.authedRequest = function() {
-                return Promise.resolve(AES256_KEY_BACKUP_DATA);
+        it("can restore from backup (AES-256 version)", function () {
+            client.http.authedRequest = function () {
+                return Promise.resolve<any>(AES256_KEY_BACKUP_DATA);
             };
-            return client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                ROOM_ID,
-                SESSION_ID,
-                AES256_BACKUP_INFO,
-            ).then(() => {
-                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-            }).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-                expect(res.untrusted).toBeFalsy(); // keys from AES backup are trusted
-            });
+            return client
+                .restoreKeyBackupWithRecoveryKey(
+                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+                    ROOM_ID,
+                    SESSION_ID,
+                    AES256_BACKUP_INFO,
+                )
+                .then(() => {
+                    return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
+                })
+                .then((res) => {
+                    expect(res.clearEvent.content).toEqual("testytest");
+                    expect(res.untrusted).toBeFalsy(); // keys from AES backup are trusted
+                });
         });
 
-        it('can restore backup by room (Curve25519 version)', function() {
-            client.http.authedRequest = function() {
-                return Promise.resolve({
+        it("can restore backup by room (Curve25519 version)", function () {
+            client.http.authedRequest = function () {
+                return Promise.resolve<any>({
                     rooms: {
                         [ROOM_ID]: {
                             sessions: {
@@ -641,30 +663,35 @@ describe("MegolmBackup", function() {
                     },
                 });
             };
-            return client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                null, null, CURVE25519_BACKUP_INFO,
-            ).then(() => {
-                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-            }).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-            });
+            return client
+                .restoreKeyBackupWithRecoveryKey(
+                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+                    null!,
+                    null!,
+                    CURVE25519_BACKUP_INFO,
+                )
+                .then(() => {
+                    return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
+                })
+                .then((res) => {
+                    expect(res.clearEvent.content).toEqual("testytest");
+                });
         });
 
-        it('has working cache functions', async function() {
+        it("has working cache functions", async function () {
             const key = Uint8Array.from([1, 2, 3, 4, 5, 6, 7, 8]);
-            await client.crypto.storeSessionBackupPrivateKey(key);
-            const result = await client.crypto.getSessionBackupPrivateKey();
-            expect(new Uint8Array(result)).toEqual(key);
+            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();
+        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(CURVE25519_KEY_BACKUP_DATA);
+            client.http.authedRequest = function () {
+                return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
             };
-            await new Promise((resolve) => {
+            await new Promise<void>((resolve) => {
                 client.restoreKeyBackupWithRecoveryKey(
                     "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
                     ROOM_ID,
@@ -673,24 +700,52 @@ describe("MegolmBackup", function() {
                     { cacheCompleteCallback: resolve },
                 );
             });
-            const cachedKey = await client.crypto.getSessionBackupPrivateKey();
+            const cachedKey = await client.crypto!.getSessionBackupPrivateKey();
             expect(cachedKey).not.toBeNull();
         });
 
-        it("fails if an known algorithm is used", async function() {
+        it("fails if an known algorithm is used", async function () {
             const BAD_BACKUP_INFO = Object.assign({}, CURVE25519_BACKUP_INFO, {
                 algorithm: "this.algorithm.does.not.exist",
             });
-            client.http.authedRequest = function() {
-                return Promise.resolve(CURVE25519_KEY_BACKUP_DATA);
+            client.http.authedRequest = function () {
+                return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
             };
 
-            await expect(client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                ROOM_ID,
-                SESSION_ID,
-                BAD_BACKUP_INFO,
-            )).rejects.toThrow();
+            await expect(
+                client.restoreKeyBackupWithRecoveryKey(
+                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+                    ROOM_ID,
+                    SESSION_ID,
+                    BAD_BACKUP_INFO,
+                ),
+            ).rejects.toThrow();
+        });
+    });
+
+    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.initCrypto();
+
+            cryptoStore.countSessionsNeedingBackup = jest.fn().mockReturnValue(6);
+            await expect(client.flagAllGroupSessionsForBackup()).resolves.toBe(6);
+            client.stopClient();
         });
     });
 });

spec/unit/crypto/cross-signing.spec.ts

@@ -15,26 +15,27 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../olm-loader';
-import anotherjson from 'another-json';
-import { PkSigning } from '@matrix-org/olm';
+import "../../olm-loader";
+import anotherjson from "another-json";
+import { PkSigning } from "@matrix-org/olm";
+import HttpBackend from "matrix-mock-request";
 
 import * as olmlib from "../../../src/crypto/olmlib";
-import { MatrixError } from '../../../src/http-api';
-import { logger } from '../../../src/logger';
-import { ICrossSigningKey, ICreateClientOpts, ISignedKey } from '../../../src/client';
-import { CryptoEvent } from '../../../src/crypto';
-import { IDevice } from '../../../src/crypto/deviceinfo';
-import { TestClient } from '../../TestClient';
+import { MatrixError } from "../../../src/http-api";
+import { logger } from "../../../src/logger";
+import { ICrossSigningKey, ICreateClientOpts, ISignedKey, MatrixClient } from "../../../src/client";
+import { CryptoEvent, IBootstrapCrossSigningOpts } from "../../../src/crypto";
+import { IDevice } from "../../../src/crypto/deviceinfo";
+import { TestClient } from "../../TestClient";
 import { resetCrossSigningKeys } from "./crypto-utils";
 
-const PUSH_RULES_RESPONSE = {
+const PUSH_RULES_RESPONSE: Response = {
     method: "GET",
     path: "/pushrules/",
     data: {},
 };
 
-const filterResponse = function(userId) {
+const filterResponse = function (userId: string): Response {
     const filterPath = "/user/" + encodeURIComponent(userId) + "/filter";
     return {
         method: "POST",
@@ -43,33 +44,37 @@ const filterResponse = function(userId) {
     };
 };
 
-function setHttpResponses(httpBackend, responses) {
-    responses.forEach(response => {
-        httpBackend
-            .when(response.method, response.path)
-            .respond(200, response.data);
+interface Response {
+    method: "GET" | "PUT" | "POST" | "DELETE";
+    path: string;
+    data: object;
+}
+
+function setHttpResponses(httpBackend: HttpBackend, responses: Response[]) {
+    responses.forEach((response) => {
+        httpBackend.when(response.method, response.path).respond(200, response.data);
     });
 }
 
 async function makeTestClient(
-    userInfo: { userId: string, deviceId: string},
+    userInfo: { userId: string; deviceId: string },
     options: Partial<ICreateClientOpts> = {},
-    keys = {},
+    keys: Record<string, Uint8Array> = {},
 ) {
-    function getCrossSigningKey(type) {
-        return keys[type];
+    function getCrossSigningKey(type: string) {
+        return keys[type] ?? null;
     }
 
-    function saveCrossSigningKeys(k) {
+    function saveCrossSigningKeys(k: Record<string, Uint8Array>) {
         Object.assign(keys, k);
     }
 
     options.cryptoCallbacks = Object.assign(
-        {}, { getCrossSigningKey, saveCrossSigningKeys }, options.cryptoCallbacks || {},
-    );
-    const testClient = new TestClient(
-        userInfo.userId, userInfo.deviceId, undefined, undefined, options,
+        {},
+        { getCrossSigningKey, saveCrossSigningKeys },
+        options.cryptoCallbacks || {},
     );
+    const testClient = new TestClient(userInfo.userId, userInfo.deviceId, undefined, undefined, options);
     const client = testClient.client;
 
     await client.initCrypto();
@@ -77,24 +82,25 @@ async function makeTestClient(
     return { client, httpBackend: testClient.httpBackend };
 }
 
-describe("Cross Signing", function() {
+describe("Cross Signing", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn("Not running megolm backup unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return global.Olm.init();
     });
 
-    it("should sign the master key with the device key", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should sign the master key with the device key", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = jest.fn().mockImplementation(async (auth, keys) => {
             await olmlib.verifySignature(
-                alice.crypto.olmDevice, keys.master_key, "@alice:example.com",
-                "Osborne2", alice.crypto.olmDevice.deviceEd25519Key,
+                alice.crypto!.olmDevice,
+                keys.master_key,
+                "@alice:example.com",
+                "Osborne2",
+                alice.crypto!.olmDevice.deviceEd25519Key!,
             );
         });
         alice.uploadKeySignatures = async () => ({ failures: {} });
@@ -102,24 +108,22 @@ describe("Cross Signing", function() {
         alice.getAccountDataFromServer = async <T>() => ({} as T);
         // set Alice's cross-signing key
         await alice.bootstrapCrossSigning({
-            authUploadDeviceSigningKeys: async func => { await func({}); },
+            authUploadDeviceSigningKeys: async (func) => {
+                await func({});
+            },
         });
         expect(alice.uploadDeviceSigningKeys).toHaveBeenCalled();
         alice.stopClient();
     });
 
-    it("should abort bootstrap if device signing auth fails", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should abort bootstrap if device signing auth fails", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async (auth, keys) => {
             const errorResponse = {
                 session: "sessionId",
                 flows: [
                     {
-                        stages: [
-                            "m.login.password",
-                        ],
+                        stages: ["m.login.password"],
                     },
                 ],
                 params: {},
@@ -141,8 +145,10 @@ describe("Cross Signing", function() {
         };
         alice.uploadKeySignatures = async () => ({ failures: {} });
         alice.setAccountData = async () => ({});
-        alice.getAccountDataFromServer = async <T extends {[k: string]: any}>(): Promise<T> => ({} as T);
-        const authUploadDeviceSigningKeys = async func => await func({});
+        alice.getAccountDataFromServer = async <T extends { [k: string]: any }>(): Promise<T | null> => ({} as T);
+        const authUploadDeviceSigningKeys: IBootstrapCrossSigningOpts["authUploadDeviceSigningKeys"] = async (func) => {
+            await func({});
+        };
 
         // Try bootstrap, expecting `authUploadDeviceSigningKeys` to pass
         // through failure, stopping before actually applying changes.
@@ -152,7 +158,7 @@ describe("Cross Signing", function() {
                 authUploadDeviceSigningKeys,
             });
         } catch (e) {
-            if (e.errcode === "M_FORBIDDEN") {
+            if ((<MatrixError>e).errcode === "M_FORBIDDEN") {
                 bootstrapDidThrow = true;
             }
         }
@@ -160,16 +166,14 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should upload a signature when a user is verified", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should upload a signature when a user is verified", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
         // set Alice's cross-signing key
         await resetCrossSigningKeys(alice);
         // Alice downloads Bob's device key
-        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto!.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -195,18 +199,14 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it.skip("should get cross-signing keys from sync", async function() {
+    it.skip("should get cross-signing keys from sync", async function () {
         const masterKey = new Uint8Array([
-            0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82,
-            0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef,
-            0xae, 0xb1, 0x05, 0xc1, 0xe7, 0x62, 0x78, 0xa6,
-            0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
+            0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82, 0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef, 0xae, 0xb1,
+            0x05, 0xc1, 0xe7, 0x62, 0x78, 0xa6, 0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
         ]);
         const selfSigningKey = new Uint8Array([
-            0x1e, 0xf4, 0x01, 0x6d, 0x4f, 0xa1, 0x73, 0x66,
-            0x6b, 0xf8, 0x93, 0xf5, 0xb0, 0x4d, 0x17, 0xc0,
-            0x17, 0xb5, 0xa5, 0xf6, 0x59, 0x11, 0x8b, 0x49,
-            0x34, 0xf2, 0x4b, 0x64, 0x9b, 0x52, 0xf8, 0x5f,
+            0x1e, 0xf4, 0x01, 0x6d, 0x4f, 0xa1, 0x73, 0x66, 0x6b, 0xf8, 0x93, 0xf5, 0xb0, 0x4d, 0x17, 0xc0, 0x17, 0xb5,
+            0xa5, 0xf6, 0x59, 0x11, 0x8b, 0x49, 0x34, 0xf2, 0x4b, 0x64, 0x9b, 0x52, 0xf8, 0x5f,
         ]);
 
         const { client: alice, httpBackend } = await makeTestClient(
@@ -214,8 +214,8 @@ describe("Cross Signing", function() {
             {
                 cryptoCallbacks: {
                     // will be called to sign our own device
-                    getCrossSigningKey: async type => {
-                        if (type === 'master') {
+                    getCrossSigningKey: async (type) => {
+                        if (type === "master") {
                             return masterKey;
                         } else {
                             return selfSigningKey;
@@ -238,12 +238,11 @@ describe("Cross Signing", function() {
             alice.uploadKeySignatures = jest.fn().mockImplementation(async (content) => {
                 try {
                     await olmlib.verifySignature(
-                        alice.crypto.olmDevice,
-                        content["@alice:example.com"][
-                            "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk"
-                        ],
+                        alice.crypto!.olmDevice,
+                        content["@alice:example.com"]["nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk"],
                         "@alice:example.com",
-                        "Osborne2", alice.crypto.olmDevice.deviceEd25519Key,
+                        "Osborne2",
+                        alice.crypto!.olmDevice.deviceEd25519Key!,
                     );
                     olmlib.pkVerify(
                         content["@alice:example.com"]["Osborne2"],
@@ -258,24 +257,18 @@ describe("Cross Signing", function() {
         });
 
         // @ts-ignore private property
-        const deviceInfo = alice.crypto.deviceList.devices["@alice:example.com"]
-            .Osborne2;
+        const deviceInfo = alice.crypto!.deviceList.devices["@alice:example.com"].Osborne2;
         const aliceDevice = {
             user_id: "@alice:example.com",
             device_id: "Osborne2",
             keys: deviceInfo.keys,
             algorithms: deviceInfo.algorithms,
         };
-        await alice.crypto.signObject(aliceDevice);
-        olmlib.pkSign(
-            aliceDevice as ISignedKey,
-            selfSigningKey as unknown as PkSigning,
-            "@alice:example.com",
-            '',
-        );
+        await alice.crypto!.signObject(aliceDevice);
+        olmlib.pkSign(aliceDevice as ISignedKey, selfSigningKey as unknown as PkSigning, "@alice:example.com", "");
 
         // feed sync result that includes master key, ssk, device key
-        const responses = [
+        const responses: Response[] = [
             PUSH_RULES_RESPONSE,
             {
                 method: "POST",
@@ -294,10 +287,7 @@ describe("Cross Signing", function() {
                 data: {
                     next_batch: "abcdefg",
                     device_lists: {
-                        changed: [
-                            "@alice:example.com",
-                            "@bob:example.com",
-                        ],
+                        changed: ["@alice:example.com", "@bob:example.com"],
                     },
                 },
             },
@@ -305,35 +295,35 @@ describe("Cross Signing", function() {
                 method: "POST",
                 path: "/keys/query",
                 data: {
-                    "failures": {},
-                    "device_keys": {
+                    failures: {},
+                    device_keys: {
                         "@alice:example.com": {
-                            "Osborne2": aliceDevice,
+                            Osborne2: aliceDevice,
                         },
                     },
-                    "master_keys": {
+                    master_keys: {
                         "@alice:example.com": {
                             user_id: "@alice:example.com",
                             usage: ["master"],
                             keys: {
                                 "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
-                                "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
+                                    "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
                             },
                         },
                     },
-                    "self_signing_keys": {
+                    self_signing_keys: {
                         "@alice:example.com": {
                             user_id: "@alice:example.com",
                             usage: ["self-signing"],
                             keys: {
                                 "ed25519:EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ":
-                                "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
+                                    "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
                             },
                             signatures: {
                                 "@alice:example.com": {
                                     "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
-                                    "Wqx/HXR851KIi8/u/UX+fbAMtq9Uj8sr8FsOcqrLfVYa6lAmbXs"
-                                    + "Vhfy4AlZ3dnEtjgZx0U0QDrghEn2eYBeOCA",
+                                        "Wqx/HXR851KIi8/u/UX+fbAMtq9Uj8sr8FsOcqrLfVYa6lAmbXs" +
+                                        "Vhfy4AlZ3dnEtjgZx0U0QDrghEn2eYBeOCA",
                                 },
                             },
                         },
@@ -373,10 +363,8 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should use trust chain to determine device verification", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should use trust chain to determine device verification", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
         // set Alice's cross-signing key
@@ -401,7 +389,7 @@ describe("Cross Signing", function() {
                 ["ed25519:" + bobMasterPubkey]: sskSig,
             },
         };
-        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto!.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -435,7 +423,7 @@ describe("Cross Signing", function() {
             verified: 0,
             known: false,
         };
-        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
+        alice.crypto!.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: bobDevice,
         });
         // Bob's device key should be TOFU
@@ -463,15 +451,15 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it.skip("should trust signatures received from other devices", async function() {
-        const aliceKeys: Record<string, PkSigning> = {};
+    it.skip("should trust signatures received from other devices", async function () {
+        const aliceKeys: Record<string, Uint8Array> = {};
         const { client: alice, httpBackend } = await makeTestClient(
             { userId: "@alice:example.com", deviceId: "Osborne2" },
-            null,
+            undefined,
             aliceKeys,
         );
-        alice.crypto.deviceList.startTrackingDeviceList("@bob:example.com");
-        alice.crypto.deviceList.stopTrackingAllDeviceLists = () => {};
+        alice.crypto!.deviceList.startTrackingDeviceList("@bob:example.com");
+        alice.crypto!.deviceList.stopTrackingAllDeviceLists = () => {};
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
 
@@ -479,14 +467,12 @@ describe("Cross Signing", function() {
         await resetCrossSigningKeys(alice);
 
         const selfSigningKey = new Uint8Array([
-            0x1e, 0xf4, 0x01, 0x6d, 0x4f, 0xa1, 0x73, 0x66,
-            0x6b, 0xf8, 0x93, 0xf5, 0xb0, 0x4d, 0x17, 0xc0,
-            0x17, 0xb5, 0xa5, 0xf6, 0x59, 0x11, 0x8b, 0x49,
-            0x34, 0xf2, 0x4b, 0x64, 0x9b, 0x52, 0xf8, 0x5f,
+            0x1e, 0xf4, 0x01, 0x6d, 0x4f, 0xa1, 0x73, 0x66, 0x6b, 0xf8, 0x93, 0xf5, 0xb0, 0x4d, 0x17, 0xc0, 0x17, 0xb5,
+            0xa5, 0xf6, 0x59, 0x11, 0x8b, 0x49, 0x34, 0xf2, 0x4b, 0x64, 0x9b, 0x52, 0xf8, 0x5f,
         ]);
 
         const keyChangePromise = new Promise<void>((resolve, reject) => {
-            alice.crypto.deviceList.once(CryptoEvent.UserCrossSigningUpdated, (userId) => {
+            alice.crypto!.deviceList.once(CryptoEvent.UserCrossSigningUpdated, (userId) => {
                 if (userId === "@bob:example.com") {
                     resolve();
                 }
@@ -494,15 +480,14 @@ describe("Cross Signing", function() {
         });
 
         // @ts-ignore private property
-        const deviceInfo = alice.crypto.deviceList.devices["@alice:example.com"]
-            .Osborne2;
+        const deviceInfo = alice.crypto!.deviceList.devices["@alice:example.com"].Osborne2;
         const aliceDevice = {
             user_id: "@alice:example.com",
             device_id: "Osborne2",
             keys: deviceInfo.keys,
             algorithms: deviceInfo.algorithms,
         };
-        await alice.crypto.signObject(aliceDevice);
+        await alice.crypto!.signObject(aliceDevice);
 
         const bobOlmAccount = new global.Olm.Account();
         bobOlmAccount.create();
@@ -527,29 +512,23 @@ describe("Cross Signing", function() {
             verified: 0,
             known: false,
         };
-        olmlib.pkSign(
-            bobDevice,
-            selfSigningKey as unknown as PkSigning,
-            "@bob:example.com",
-            '',
-        );
+        olmlib.pkSign(bobDevice, selfSigningKey as unknown as PkSigning, "@bob:example.com", "");
 
         const bobMaster: ICrossSigningKey = {
             user_id: "@bob:example.com",
             usage: ["master"],
             keys: {
-                "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
-                "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
+                "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk": "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
             },
         };
-        olmlib.pkSign(bobMaster, aliceKeys.user_signing, "@alice:example.com", '');
+        olmlib.pkSign(bobMaster, aliceKeys.user_signing, "@alice:example.com", "");
 
         // Alice downloads Bob's keys
         // - device key
         // - ssk
         // - master key signed by her usk (pretend that it was signed by another
         //   of Alice's devices)
-        const responses = [
+        const responses: Response[] = [
             PUSH_RULES_RESPONSE,
             {
                 method: "POST",
@@ -568,9 +547,7 @@ describe("Cross Signing", function() {
                 data: {
                     next_batch: "abcdefg",
                     device_lists: {
-                        changed: [
-                            "@bob:example.com",
-                        ],
+                        changed: ["@bob:example.com"],
                     },
                 },
             },
@@ -578,31 +555,31 @@ describe("Cross Signing", function() {
                 method: "POST",
                 path: "/keys/query",
                 data: {
-                    "failures": {},
-                    "device_keys": {
+                    failures: {},
+                    device_keys: {
                         "@alice:example.com": {
-                            "Osborne2": aliceDevice,
+                            Osborne2: aliceDevice,
                         },
                         "@bob:example.com": {
-                            "Dynabook": bobDevice,
+                            Dynabook: bobDevice,
                         },
                     },
-                    "master_keys": {
+                    master_keys: {
                         "@bob:example.com": bobMaster,
                     },
-                    "self_signing_keys": {
+                    self_signing_keys: {
                         "@bob:example.com": {
                             user_id: "@bob:example.com",
                             usage: ["self-signing"],
                             keys: {
                                 "ed25519:EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ":
-                                "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
+                                    "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
                             },
                             signatures: {
                                 "@bob:example.com": {
                                     "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
-                                    "2KLiufImvEbfJuAFvsaZD+PsL8ELWl7N1u9yr/9hZvwRghBfQMB"
-                                    + "LAI86b1kDV9+Cq1lt85ykReeCEzmTEPY2BQ",
+                                        "2KLiufImvEbfJuAFvsaZD+PsL8ELWl7N1u9yr/9hZvwRghBfQMB" +
+                                        "LAI86b1kDV9+Cq1lt85ykReeCEzmTEPY2BQ",
                                 },
                             },
                         },
@@ -638,10 +615,8 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should dis-trust an unsigned device", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should dis-trust an unsigned device", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
         // set Alice's cross-signing key
@@ -667,7 +642,7 @@ describe("Cross Signing", function() {
                 ["ed25519:" + bobMasterPubkey]: sskSig,
             },
         };
-        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto!.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -690,7 +665,7 @@ describe("Cross Signing", function() {
                 "ed25519:Dynabook": "someOtherPubkey",
             },
         };
-        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
+        alice.crypto!.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: bobDevice as unknown as IDevice,
         });
         // Bob's device key should be untrusted
@@ -708,10 +683,8 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should dis-trust a user when their ssk changes", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should dis-trust a user when their ssk changes", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
         await resetCrossSigningKeys(alice);
@@ -735,7 +708,7 @@ describe("Cross Signing", function() {
                 ["ed25519:" + bobMasterPubkey]: sskSig,
             },
         };
-        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto!.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -770,7 +743,7 @@ describe("Cross Signing", function() {
                 },
             },
         };
-        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
+        alice.crypto!.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: bobDevice,
         });
         // Alice verifies Bob's SSK
@@ -802,7 +775,7 @@ describe("Cross Signing", function() {
                 ["ed25519:" + bobMasterPubkey2]: sskSig2,
             },
         };
-        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto!.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -838,8 +811,8 @@ describe("Cross Signing", function() {
 
         // Alice gets new signature for device
         const sig2 = bobSigning2.sign(bobDeviceString);
-        bobDevice.signatures["@bob:example.com"]["ed25519:" + bobPubkey2] = sig2;
-        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
+        bobDevice.signatures!["@bob:example.com"]["ed25519:" + bobPubkey2] = sig2;
+        alice.crypto!.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: bobDevice,
         });
 
@@ -852,8 +825,8 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should offer to upgrade device verifications to cross-signing", async function() {
-        let upgradeResolveFunc;
+    it("should offer to upgrade device verifications to cross-signing", async function () {
+        let upgradeResolveFunc: Function;
 
         const { client: alice } = await makeTestClient(
             { userId: "@alice:example.com", deviceId: "Osborne2" },
@@ -866,31 +839,25 @@ describe("Cross Signing", function() {
                     },
                 },
             },
-
-        );
-        const { client: bob } = await makeTestClient(
-            { userId: "@bob:example.com", deviceId: "Dynabook" },
         );
+        const { client: bob } = await makeTestClient({ userId: "@bob:example.com", deviceId: "Dynabook" });
 
         bob.uploadDeviceSigningKeys = async () => ({});
         bob.uploadKeySignatures = async () => ({ failures: {} });
         // set Bob's cross-signing key
         await resetCrossSigningKeys(bob);
-        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
+        alice.crypto!.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: {
                 algorithms: ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
                 keys: {
-                    "curve25519:Dynabook": bob.crypto.olmDevice.deviceCurve25519Key,
-                    "ed25519:Dynabook": bob.crypto.olmDevice.deviceEd25519Key,
+                    "curve25519:Dynabook": bob.crypto!.olmDevice.deviceCurve25519Key!,
+                    "ed25519:Dynabook": bob.crypto!.olmDevice.deviceEd25519Key!,
                 },
                 verified: 1,
                 known: true,
             },
         });
-        alice.crypto.deviceList.storeCrossSigningForUser(
-            "@bob:example.com",
-            bob.crypto.crossSigningInfo.toStorage(),
-        );
+        alice.crypto!.deviceList.storeCrossSigningForUser("@bob:example.com", bob.crypto!.crossSigningInfo.toStorage());
 
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
@@ -909,8 +876,9 @@ describe("Cross Signing", function() {
         expect(bobTrust.isTofu()).toBeTruthy();
 
         // "forget" that Bob is trusted
-        delete alice.crypto.deviceList.crossSigningInfo["@bob:example.com"]
-            .keys.master.signatures["@alice:example.com"];
+        delete alice.crypto!.deviceList.crossSigningInfo["@bob:example.com"].keys.master.signatures![
+            "@alice:example.com"
+        ];
 
         const bobTrust2 = alice.checkUserTrust("@bob:example.com");
         expect(bobTrust2.isCrossSigningVerified()).toBeFalsy();
@@ -919,9 +887,9 @@ describe("Cross Signing", function() {
         upgradePromise = new Promise((resolve) => {
             upgradeResolveFunc = resolve;
         });
-        alice.crypto.deviceList.emit(CryptoEvent.UserCrossSigningUpdated, "@bob:example.com");
+        alice.crypto!.deviceList.emit(CryptoEvent.UserCrossSigningUpdated, "@bob:example.com");
         await new Promise((resolve) => {
-            alice.crypto.on(CryptoEvent.UserTrustStatusChanged, resolve);
+            alice.crypto!.on(CryptoEvent.UserTrustStatusChanged, resolve);
         });
         await upgradePromise;
 
@@ -932,91 +900,83 @@ describe("Cross Signing", function() {
         bob.stopClient();
     });
 
-    it(
-        "should observe that our own device is cross-signed, even if this device doesn't trust the key",
-        async function() {
-            const { client: alice } = await makeTestClient(
-                { userId: "@alice:example.com", deviceId: "Osborne2" },
-            );
-            alice.uploadDeviceSigningKeys = async () => ({});
-            alice.uploadKeySignatures = async () => ({ failures: {} });
+    it("should observe that our own device is cross-signed, even if this device doesn't trust the key", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
+        alice.uploadDeviceSigningKeys = async () => ({});
+        alice.uploadKeySignatures = async () => ({ failures: {} });
 
-            // Generate Alice's SSK etc
-            const aliceMasterSigning = new global.Olm.PkSigning();
-            const aliceMasterPrivkey = aliceMasterSigning.generate_seed();
-            const aliceMasterPubkey = aliceMasterSigning.init_with_seed(aliceMasterPrivkey);
-            const aliceSigning = new global.Olm.PkSigning();
-            const alicePrivkey = aliceSigning.generate_seed();
-            const alicePubkey = aliceSigning.init_with_seed(alicePrivkey);
-            const aliceSSK: ICrossSigningKey = {
-                user_id: "@alice:example.com",
-                usage: ["self_signing"],
-                keys: {
-                    ["ed25519:" + alicePubkey]: alicePubkey,
+        // Generate Alice's SSK etc
+        const aliceMasterSigning = new global.Olm.PkSigning();
+        const aliceMasterPrivkey = aliceMasterSigning.generate_seed();
+        const aliceMasterPubkey = aliceMasterSigning.init_with_seed(aliceMasterPrivkey);
+        const aliceSigning = new global.Olm.PkSigning();
+        const alicePrivkey = aliceSigning.generate_seed();
+        const alicePubkey = aliceSigning.init_with_seed(alicePrivkey);
+        const aliceSSK: ICrossSigningKey = {
+            user_id: "@alice:example.com",
+            usage: ["self_signing"],
+            keys: {
+                ["ed25519:" + alicePubkey]: alicePubkey,
+            },
+        };
+        const sskSig = aliceMasterSigning.sign(anotherjson.stringify(aliceSSK));
+        aliceSSK.signatures = {
+            "@alice:example.com": {
+                ["ed25519:" + aliceMasterPubkey]: sskSig,
+            },
+        };
+
+        // Alice's device downloads the keys, but doesn't trust them yet
+        alice.crypto!.deviceList.storeCrossSigningForUser("@alice:example.com", {
+            keys: {
+                master: {
+                    user_id: "@alice:example.com",
+                    usage: ["master"],
+                    keys: {
+                        ["ed25519:" + aliceMasterPubkey]: aliceMasterPubkey,
+                    },
                 },
-            };
-            const sskSig = aliceMasterSigning.sign(anotherjson.stringify(aliceSSK));
-            aliceSSK.signatures = {
+                self_signing: aliceSSK,
+            },
+            firstUse: true,
+            crossSigningVerifiedBefore: false,
+        });
+
+        // Alice has a second device that's cross-signed
+        const aliceDeviceId = "Dynabook";
+        const aliceUnsignedDevice = {
+            user_id: "@alice:example.com",
+            device_id: aliceDeviceId,
+            algorithms: ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
+            keys: {
+                "curve25519:Dynabook": "somePubkey",
+                "ed25519:Dynabook": "someOtherPubkey",
+            },
+        };
+        const sig = aliceSigning.sign(anotherjson.stringify(aliceUnsignedDevice));
+        const aliceCrossSignedDevice: IDevice = {
+            ...aliceUnsignedDevice,
+            verified: 0,
+            known: false,
+            signatures: {
                 "@alice:example.com": {
-                    ["ed25519:" + aliceMasterPubkey]: sskSig,
+                    ["ed25519:" + alicePubkey]: sig,
                 },
-            };
+            },
+        };
+        alice.crypto!.deviceList.storeDevicesForUser("@alice:example.com", {
+            [aliceDeviceId]: aliceCrossSignedDevice,
+        });
 
-            // Alice's device downloads the keys, but doesn't trust them yet
-            alice.crypto.deviceList.storeCrossSigningForUser("@alice:example.com", {
-                keys: {
-                    master: {
-                        user_id: "@alice:example.com",
-                        usage: ["master"],
-                        keys: {
-                            ["ed25519:" + aliceMasterPubkey]: aliceMasterPubkey,
-                        },
-                    },
-                    self_signing: aliceSSK,
-                },
-                firstUse: true,
-                crossSigningVerifiedBefore: false,
-            });
+        // We don't trust the cross-signing keys yet...
+        expect(alice.checkDeviceTrust("@alice:example.com", aliceDeviceId).isCrossSigningVerified()).toBeFalsy();
+        // ... but we do acknowledge that the device is signed by them
+        expect(alice.checkIfOwnDeviceCrossSigned(aliceDeviceId)).toBeTruthy();
+        alice.stopClient();
+    });
 
-            // Alice has a second device that's cross-signed
-            const aliceDeviceId = 'Dynabook';
-            const aliceUnsignedDevice = {
-                user_id: "@alice:example.com",
-                device_id: aliceDeviceId,
-                algorithms: ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
-                keys: {
-                    "curve25519:Dynabook": "somePubkey",
-                    "ed25519:Dynabook": "someOtherPubkey",
-                },
-            };
-            const sig = aliceSigning.sign(anotherjson.stringify(aliceUnsignedDevice));
-            const aliceCrossSignedDevice: IDevice = {
-                ...aliceUnsignedDevice,
-                verified: 0,
-                known: false,
-                signatures: {
-                    "@alice:example.com": {
-                        ["ed25519:" + alicePubkey]: sig,
-                    },
-                } };
-            alice.crypto.deviceList.storeDevicesForUser("@alice:example.com", {
-                [aliceDeviceId]: aliceCrossSignedDevice,
-            });
-
-            // We don't trust the cross-signing keys yet...
-            expect(
-                alice.checkDeviceTrust("@alice:example.com", aliceDeviceId).isCrossSigningVerified(),
-            ).toBeFalsy();
-            // ... but we do acknowledge that the device is signed by them
-            expect(alice.checkIfOwnDeviceCrossSigned(aliceDeviceId)).toBeTruthy();
-            alice.stopClient();
-        },
-    );
-
-    it("should observe that our own device isn't cross-signed", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should observe that our own device isn't cross-signed", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
 
@@ -1042,7 +1002,7 @@ describe("Cross Signing", function() {
         };
 
         // Alice's device downloads the keys
-        alice.crypto.deviceList.storeCrossSigningForUser("@alice:example.com", {
+        alice.crypto!.deviceList.storeCrossSigningForUser("@alice:example.com", {
             keys: {
                 master: {
                     user_id: "@alice:example.com",
@@ -1067,11 +1027,127 @@ describe("Cross Signing", function() {
                 "ed25519:Dynabook": "someOtherPubkey",
             },
         };
-        alice.crypto.deviceList.storeDevicesForUser("@alice:example.com", {
+        alice.crypto!.deviceList.storeDevicesForUser("@alice:example.com", {
             [deviceId]: aliceNotCrossSignedDevice,
         });
 
         expect(alice.checkIfOwnDeviceCrossSigned(deviceId)).toBeFalsy();
         alice.stopClient();
     });
+
+    it("checkIfOwnDeviceCrossSigned should sanely handle unknown devices", async () => {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
+        alice.uploadDeviceSigningKeys = async () => ({});
+        alice.uploadKeySignatures = async () => ({ failures: {} });
+
+        // Generate Alice's SSK etc
+        const aliceMasterSigning = new global.Olm.PkSigning();
+        const aliceMasterPrivkey = aliceMasterSigning.generate_seed();
+        const aliceMasterPubkey = aliceMasterSigning.init_with_seed(aliceMasterPrivkey);
+        const aliceSigning = new global.Olm.PkSigning();
+        const alicePrivkey = aliceSigning.generate_seed();
+        const alicePubkey = aliceSigning.init_with_seed(alicePrivkey);
+        const aliceSSK: ICrossSigningKey = {
+            user_id: "@alice:example.com",
+            usage: ["self_signing"],
+            keys: {
+                ["ed25519:" + alicePubkey]: alicePubkey,
+            },
+        };
+        const sskSig = aliceMasterSigning.sign(anotherjson.stringify(aliceSSK));
+        aliceSSK.signatures = {
+            "@alice:example.com": {
+                ["ed25519:" + aliceMasterPubkey]: sskSig,
+            },
+        };
+
+        // Alice's device downloads the keys
+        alice.crypto!.deviceList.storeCrossSigningForUser("@alice:example.com", {
+            keys: {
+                master: {
+                    user_id: "@alice:example.com",
+                    usage: ["master"],
+                    keys: {
+                        ["ed25519:" + aliceMasterPubkey]: aliceMasterPubkey,
+                    },
+                },
+                self_signing: aliceSSK,
+            },
+            firstUse: true,
+            crossSigningVerifiedBefore: false,
+        });
+
+        expect(alice.checkIfOwnDeviceCrossSigned("notadevice")).toBeFalsy();
+        alice.stopClient();
+    });
+
+    it("checkIfOwnDeviceCrossSigned should sanely handle unknown users", async () => {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
+        expect(alice.checkIfOwnDeviceCrossSigned("notadevice")).toBeFalsy();
+        alice.stopClient();
+    });
+});
+
+describe("userHasCrossSigningKeys", function () {
+    if (!global.Olm) {
+        return;
+    }
+
+    beforeAll(() => {
+        return global.Olm.init();
+    });
+
+    let aliceClient: MatrixClient;
+    let httpBackend: HttpBackend;
+    beforeEach(async () => {
+        const testClient = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
+        aliceClient = testClient.client;
+        httpBackend = testClient.httpBackend;
+    });
+
+    afterEach(() => {
+        aliceClient.stopClient();
+    });
+
+    it("should download devices and return true if one is a cross-signing key", async () => {
+        httpBackend.when("POST", "/keys/query").respond(200, {
+            master_keys: {
+                "@alice:example.com": {
+                    user_id: "@alice:example.com",
+                    usage: ["master"],
+                    keys: {
+                        "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
+                            "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
+                    },
+                },
+            },
+        });
+
+        let result: boolean;
+        await Promise.all([
+            httpBackend.flush("/keys/query"),
+            aliceClient.userHasCrossSigningKeys().then((res) => {
+                result = res;
+            }),
+        ]);
+        expect(result!).toBeTruthy();
+    });
+
+    it("should download devices and return false if there is no cross-signing key", async () => {
+        httpBackend.when("POST", "/keys/query").respond(200, {});
+
+        let result: boolean;
+        await Promise.all([
+            httpBackend.flush("/keys/query"),
+            aliceClient.userHasCrossSigningKeys().then((res) => {
+                result = res;
+            }),
+        ]);
+        expect(result!).toBeFalsy();
+    });
+
+    it("throws an error if crypto is disabled", () => {
+        aliceClient["cryptoBackend"] = undefined;
+        expect(() => aliceClient.userHasCrossSigningKeys()).toThrowError("encryption disabled");
+    });
 });

spec/unit/crypto/crypto-utils.ts

@@ -1,34 +1,33 @@
-import { IRecoveryKey } from '../../../src/crypto/api';
-import { CrossSigningLevel } from '../../../src/crypto/CrossSigning';
-import { IndexedDBCryptoStore } from '../../../src/crypto/store/indexeddb-crypto-store';
+import { IRecoveryKey } from "../../../src/crypto/api";
+import { CrossSigningLevel } from "../../../src/crypto/CrossSigning";
+import { IndexedDBCryptoStore } from "../../../src/crypto/store/indexeddb-crypto-store";
+import { MatrixClient } from "../../../src";
+import { CryptoEvent } from "../../../src/crypto";
 
 // 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,
-    { level }: { level?: CrossSigningLevel} = {},
+    client: MatrixClient,
+    { level }: { level?: CrossSigningLevel } = {},
 ): Promise<void> {
-    const crypto = client.crypto;
+    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);
-            },
-        );
+        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("crossSigning.keysChanged", {});
+    crypto.emit(CryptoEvent.KeysChanged, {});
+    // @ts-ignore
     await crypto.afterCrossSigningLocalKeyChange();
 }
 
@@ -39,7 +38,7 @@ export async function createSecretStorageKey(): Promise<IRecoveryKey> {
     decryption.free();
     return {
         // `pubkey` not used anymore with symmetric 4S
-        keyInfo: { pubkey: storagePublicKey, key: undefined },
+        keyInfo: { pubkey: storagePublicKey, key: undefined! },
         privateKey: storagePrivateKey,
     };
 }

spec/unit/crypto/dehydration.spec.ts

@@ -0,0 +1,138 @@
+/*
+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 = global.Olm;
+
+describe("Dehydration", () => {
+    if (!global.Olm) {
+        logger.warn("Not running dehydration unit tests: libolm not present");
+        return;
+    }
+
+    beforeAll(function () {
+        return global.Olm.init();
+    });
+
+    it("should rehydrate a dehydrated device", async () => {
+        const key = new Uint8Array([1, 2, 3]);
+        const alice = new TestClient("@alice:example.com", "Osborne2", undefined, undefined, {
+            cryptoCallbacks: {
+                getDehydrationKey: async (t) => key,
+            },
+        });
+
+        const 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.initCrypto();
+
+        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();
+        }
+    });
+});

spec/unit/crypto/outgoing-room-key-requests.spec.ts

@@ -14,74 +14,78 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {
-    IndexedDBCryptoStore,
-} from '../../../src/crypto/store/indexeddb-crypto-store';
-import { MemoryCryptoStore } from '../../../src/crypto/store/memory-crypto-store';
-import { RoomKeyRequestState } from '../../../src/crypto/OutgoingRoomKeyRequestManager';
+import { CryptoStore } from "../../../src/crypto/store/base";
+import { IndexedDBCryptoStore } from "../../../src/crypto/store/indexeddb-crypto-store";
+import { LocalStorageCryptoStore } from "../../../src/crypto/store/localStorage-crypto-store";
+import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
+import { RoomKeyRequestState } from "../../../src/crypto/OutgoingRoomKeyRequestManager";
 
-import 'fake-indexeddb/auto';
-import 'jest-localstorage-mock';
+import "fake-indexeddb/auto";
+import "jest-localstorage-mock";
 
 const requests = [
     {
         requestId: "A",
-        requestBody: { session_id: "A", room_id: "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" },
+        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" },
+        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(global.indexedDB, "tests")],
-    ["LocalStorageCryptoStore",
-        () => new IndexedDBCryptoStore(undefined, "tests")],
-    ["MemoryCryptoStore", () => {
-        const store = new IndexedDBCryptoStore(undefined, "tests");
-        // @ts-ignore set private properties
-        store.backend = new MemoryCryptoStore();
-        // @ts-ignore
-        store.backendPromise = Promise.resolve(store.backend);
-        return store;
-    }],
-])("Outgoing room key requests [%s]", function(name, dbFactory) {
-    let store;
+    ["IndexedDBCryptoStore", () => new IndexedDBCryptoStore(global.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),
-        ));
+        await Promise.all(requests.map((request) => store.getOrAddOutgoingRoomKeyRequest(request)));
     });
 
-    it("getAllOutgoingRoomKeyRequestsByState retrieves all entries in a given state",
-        async () => {
-            const r = await
-            store.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);
-            expect(r).toHaveLength(2);
-            requests.filter((e) => e.state === RoomKeyRequestState.Sent).forEach((e) => {
+    it("getAllOutgoingRoomKeyRequestsByState retrieves all entries in a given state", async () => {
+        const r = await store.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);
+        expect(r).toHaveLength(2);
+        requests
+            .filter((e) => e.state === RoomKeyRequestState.Sent)
+            .forEach((e) => {
                 expect(r).toContainEqual(e);
             });
-        });
+    });
 
-    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);
-        });
+    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);
+    });
 });