v34.1.0

Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>

.babelrc

@@ -1,19 +0,0 @@
-{
-    "sourceMaps": true,
-    "presets": [
-        ["@babel/preset-env", {
-            "targets": {
-                "node": 10
-            },
-            "modules": "commonjs"
-        }],
-        "@babel/preset-typescript"
-    ],
-    "plugins": [
-        "@babel/plugin-proposal-numeric-separator",
-        "@babel/plugin-proposal-class-properties",
-        "@babel/plugin-proposal-object-rest-spread",
-        "@babel/plugin-syntax-dynamic-import",
-        "@babel/plugin-transform-runtime"
-    ]
-}

.editorconfig

@@ -21,3 +21,6 @@ insert_final_newline = true
 indent_style = space
 indent_size = 4
 trim_trailing_whitespace = true
+
+[*.{yml,yaml}]
+indent_size = 4

.eslintignore

@@ -0,0 +1 @@
+_docs

.eslintrc.js

@@ -1,58 +1,142 @@
 module.exports = {
-    plugins: [
-        "matrix-org",
-    ],
-    extends: [
-        "plugin:matrix-org/babel",
-    ],
+    plugins: ["matrix-org", "import", "jsdoc"],
+    extends: ["plugin:matrix-org/babel", "plugin:matrix-org/jest", "plugin:import/typescript"],
+    parserOptions: {
+        project: ["./tsconfig.json"],
+    },
     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",
+            {
+                name: "events",
+                message: "Please use TypedEventEmitter instead",
+            },
+        ],
+
+        "no-restricted-properties": [
+            "error",
+            {
+                object: "window",
+                property: "setImmediate",
+                message: "Use setTimeout instead.",
+            },
+        ],
+        "no-restricted-globals": [
+            "error",
+            {
+                name: "setImmediate",
+                message: "Use setTimeout 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",
+                    },
+                ],
+            },
+        ],
+        // Disabled tests are a reality for now but as soon as all of the xits are
+        // eliminated, we should enforce this.
+        "jest/no-disabled-tests": "off",
+        // Also treat "oldBackendOnly" as a test function.
+        // Used in some crypto tests.
+        "jest/no-standalone-expect": [
+            "error",
+            {
+                additionalTestBlockFunctions: ["beforeAll", "beforeEach", "oldBackendOnly", "newBackendOnly"],
+            },
+        ],
     },
-    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 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",
+            },
         },
-    }],
+        {
+            files: ["src/**/*.ts"],
+            rules: {
+                "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

@@ -0,0 +1,42 @@
+# Minor white-space adjustments
+1d1d59c75744e1f6a2be1cb3e0d1bd9ded5f8025
+# Import ordering and spacing: eslint-plugin-import
+80aaa6c32b50601f82e0c991c24e5a4590f39463
+# Minor white-space adjustment
+8fb036ba2d01fab66dc4373802ccf19b5cac8541
+# Minor white-space adjustment
+b63de6a902a9e1f8ffd7697dea33820fc04f028e
+3ca84cfc491b0987eec1f13f13cae58d2032bf54
+# Conform to new typescript eslint rules
+a87858840b57514603f63e2abbbda4f107f05a77
+5cf6684129a921295f5593173f16f192336fe0a2
+# Comply with new member-delimiter-style rule
+b2ad957d298720d3e026b6bd91be0c403338361a
+# Fix semicolons in TS files
+e2ec8952e38b8fea3f0ccaa09ecb42feeba0d923
+# Migrate to `eslint-plugin-matrix-org`
+# and `babel/...` to `@babel/...` migration
+09fac77ce0d9bcf6637088c29afab84084f0e739
+102704e91a70643bcc09721e14b0d909f0ef55c6
+# Eslint formatting
+cec00cd303787fa9008b6c48826e75ed438036fa
+# Minor eslint changes
+68bb8182e4e62d8f450f80c408c4b231b8725f1b
+c979ff6696e30ab8983ac416a3590996d84d3560
+f4a7395e3a3751a1a8e92dd302c49175a3296ad2
+# eslint --fix for dangley commas on function calls
+423175f5397910b0afe3112d6fb18283fc7d27d4
+# eslint ---fix for prefer-const
+7bca05af644e8b997dae81e568a3913d8f18d7ca
+# Fix linting on tests
+cee7f7a280a8c20bafc21c0a2911f60851f7a7ca
+# eslint --fix
+0fa9f7c6098822db1ae214f352fd1fe5c248b02c
+# eslint --fix for lots of white-space
+5abf6b9f208801c5022a47023150b5846cb0b309
+# eslint --fix
+7ed65407e6cdf292ce3cf659310c68d19dcd52b2
+# Switch to ESLint from JSHint (Google eslint rules as a base)
+e057956ede9ad1a931ff8050c411aca7907e0394
+# prettier
+349c2c2587c2885bb69eda4aa078b5383724cf5e

.github/CODEOWNERS

@@ -1 +1,15 @@
-* @matrix-org/element-web
+*                         @matrix-org/element-web-reviewers
+/.github/workflows/**     @matrix-org/element-web-team
+/package.json             @matrix-org/element-web-team
+/yarn.lock                @matrix-org/element-web-team
+/src/webrtc               @matrix-org/element-call-reviewers
+/src/matrixrtc               @matrix-org/element-call-reviewers
+/spec/*/webrtc            @matrix-org/element-call-reviewers
+/spec/*/matrixrtc            @matrix-org/element-call-reviewers
+
+/src/crypto               @matrix-org/element-crypto-web-reviewers
+/src/rust-crypto          @matrix-org/element-crypto-web-reviewers
+/spec/integ/crypto        @matrix-org/element-crypto-web-reviewers
+/spec/unit/crypto.spec.ts @matrix-org/element-crypto-web-reviewers
+/spec/unit/crypto         @matrix-org/element-crypto-web-reviewers
+/spec/unit/rust-crypto    @matrix-org/element-crypto-web-reviewers

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,7 +1,8 @@
-<!-- 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).
+-   [ ] New or updated `public`/`exported` symbols have accurate [TSDoc](https://tsdoc.org/) documentation.
+-   [ ] 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)).

.github/actions/sign-release-tarball/action.yml

@@ -0,0 +1,28 @@
+name: Sign Release Tarball
+description: Generates signature for release tarball and uploads it as a release asset
+inputs:
+    gpg-fingerprint:
+        description: Fingerprint of the GPG key to use for signing the tarball.
+        required: true
+    upload-url:
+        description: GitHub release upload URL to upload the signature file to.
+        required: true
+runs:
+    using: composite
+    steps:
+        - name: Generate tarball signature
+          shell: bash
+          run: |
+              git -c tar.tar.gz.command='gzip -cn' archive --format=tar.gz --prefix="${REPO#*/}-${VERSION#v}/" -o "/tmp/${VERSION}.tar.gz" "${VERSION}"
+              gpg -u "$GPG_FINGERPRINT" --armor --output "${VERSION}.tar.gz.asc" --detach-sig "/tmp/${VERSION}.tar.gz"
+              rm "/tmp/${VERSION}.tar.gz"
+          env:
+              GPG_FINGERPRINT: ${{ inputs.gpg-fingerprint }}
+              REPO: ${{ github.repository }}
+
+        - name: Upload tarball signature
+          if: ${{ inputs.upload-url }}
+          uses: shogo82148/actions-upload-release-asset@8f032eff0255912cc9c8455797fd6d72f25c7ab7 # v1
+          with:
+              upload_url: ${{ inputs.upload-url }}
+              asset_path: ${{ env.VERSION }}.tar.gz.asc

.github/actions/upload-release-assets/action.yml

@@ -0,0 +1,41 @@
+name: Upload release assets
+description: Uploads assets to an existing release and optionally signs them
+inputs:
+    gpg-fingerprint:
+        description: Fingerprint of the GPG key to use for signing the assets, if any.
+        required: false
+    upload-url:
+        description: GitHub release upload URL to upload the assets to.
+        required: true
+    asset-path:
+        description: |
+            The path to the asset you want to upload, if any. You can use glob patterns here.
+            Will be GPG signed and an `.asc` file included in the release artifacts if `gpg-fingerprint` is set.
+        required: true
+runs:
+    using: composite
+    steps:
+        - name: Sign assets
+          if: inputs.gpg-fingerprint
+          shell: bash
+          run: |
+              for FILE in $ASSET_PATH
+              do
+                  gpg -u "$GPG_FINGERPRINT" --armor --output "$FILE".asc --detach-sig "$FILE"
+              done
+          env:
+              GPG_FINGERPRINT: ${{ inputs.gpg-fingerprint }}
+              ASSET_PATH: ${{ inputs.asset-path }}
+
+        - name: Upload asset signatures
+          if: inputs.gpg-fingerprint
+          uses: shogo82148/actions-upload-release-asset@8f032eff0255912cc9c8455797fd6d72f25c7ab7 # v1
+          with:
+              upload_url: ${{ inputs.upload-url }}
+              asset_path: ${{ inputs.asset-path }}.asc
+
+        - name: Upload assets
+          uses: shogo82148/actions-upload-release-asset@8f032eff0255912cc9c8455797fd6d72f25c7ab7 # v1
+          with:
+              upload_url: ${{ inputs.upload-url }}
+              asset_path: ${{ inputs.asset-path }}

.github/labels.yml

@@ -0,0 +1,43 @@
+- name: "A-Element-R"
+  description: "Issues affecting the port of Element's crypto layer to Rust"
+  color: "bfd4f2"
+- name: "A-Packaging"
+  description: "Packaging, signing, releasing"
+  color: "bfd4f2"
+- name: "A-Technical-Debt"
+  color: "bfd4f2"
+- name: "A-Testing"
+  description: "Testing, code coverage, etc."
+  color: "bfd4f2"
+- name: "backport staging"
+  description: "Label to automatically backport PR to staging branch"
+  color: "B60205"
+- name: "Dependencies"
+  description: "Pull requests that update a dependency file"
+  color: "0366d6"
+- name: "Easy"
+  color: "5dc9f7"
+- name: "Sponsored"
+  color: "ffc8f4"
+- name: "T-Deprecation"
+  description: "A pull request that makes something deprecated"
+  color: "98e6ae"
+- name: "T-Other"
+  description: "Questions, user support, anything else"
+  color: "98e6ae"
+- name: "X-Blocked"
+  color: "ff7979"
+- name: "X-Breaking-Change"
+  color: "ff7979"
+- name: "X-Reverted"
+  description: "PR has been reverted"
+  color: "F68AA3"
+- name: "X-Upcoming-Release-Blocker"
+  description: "This does not affect the current release cycle but will affect the next one"
+  color: "e99695"
+- name: "Z-Community-PR"
+  description: "Issue is solved by a community member's PR"
+  color: "ededed"
+- name: "Z-Flaky-Test"
+  description: "A test is raising false alarms"
+  color: "ededed"

.github/release-drafter.yml

@@ -0,0 +1,35 @@
+name-template: "v$RESOLVED_VERSION"
+tag-template: "v$RESOLVED_VERSION"
+change-template: "* $TITLE ([#$NUMBER]($URL)). Contributed by @$AUTHOR."
+categories:
+    - title: "🚨 BREAKING CHANGES"
+      label: "X-Breaking-Change"
+    - title: "🦖 Deprecations"
+      label: "T-Deprecation"
+    - title: "✨ Features"
+      label: "T-Enhancement"
+    - title: "🐛 Bug Fixes"
+      label: "T-Defect"
+    - title: "🧰 Maintenance"
+      label: "Dependencies"
+      collapse-after: 5
+change-title-escapes: '\<*_&' # You can add # and @ to disable mentions, and add ` to disable code blocks.
+version-resolver:
+    major:
+        labels:
+            - "X-Breaking-Change"
+    default: minor
+exclude-labels:
+    - "T-Task"
+    - "X-Reverted"
+    - "backport staging"
+exclude-contributors:
+    - "RiotRobot"
+template: |
+    $CHANGES
+#no-changes-template: ""
+prerelease: true
+prerelease-identifier: rc
+include-pre-releases: false
+stable-ref: master
+staging-ref: staging

.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@9565281eda0731b1d20c4025c43339fb0a23812e # 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,33 @@
+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:
+            - name: 📥 Download artifact
+              uses: actions/download-artifact@v4
+              with:
+                  github-token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  run-id: ${{ github.event.workflow_run.id }}
+                  name: docs
+                  path: docs
+
+            - name: 📤 Deploy to Netlify
+              uses: matrix-org/netlify-pr-preview@v3
+              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
+        environment: PR Documentation Preview

.github/workflows/downstream-end-to-end-tests.yml

@@ -0,0 +1,34 @@
+# Triggers after the "Downstream artifacts" build has finished, to run the
+# matrix-react-sdk playwright tests (with access to repo secrets)
+
+name: matrix-react-sdk End to End Tests
+on:
+    merge_group:
+        types: [checks_requested]
+
+    pull_request: {}
+
+    # For now at least, we don't run this or the downstream-end-to-end-tests against pushes
+    # to develop or master.
+    #
+    #push:
+    #    branches: [develop, master]
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch || github.run_id }}
+    cancel-in-progress: ${{ github.event.workflow_run.event == 'pull_request' }}
+
+jobs:
+    playwright:
+        name: Playwright
+        uses: matrix-org/matrix-react-sdk/.github/workflows/end-to-end-tests.yaml@develop
+        permissions:
+            actions: read
+            issues: read
+            pull-requests: read
+        with:
+            matrix-js-sdk-sha: ${{ github.sha }}
+            react-sdk-repository: matrix-org/matrix-react-sdk
+            # We only want to run the playwright tests on merge queue to prevent regressions
+            # from creeping in. They take a long time to run and consume multiple concurrent runners.
+            skip: ${{ github.event_name != 'merge_group' }}

.github/workflows/notify-downstream.yaml

@@ -0,0 +1,27 @@
+name: Notify Downstream Projects
+on:
+    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: element-hq/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@ff45666b9427631e3450c54a1bcbee4d9ff4d7c0 # v3
+              with:
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  repository: ${{ matrix.repo }}
+                  event-type: ${{ matrix.event }}

.github/workflows/preview_changelog.yaml

@@ -1,12 +0,0 @@
-name: Preview Changelog
-on:
-  pull_request_target:
-    types: [ opened, edited, labeled ]
-jobs:
-    changelog:
-        runs-on: ubuntu-latest
-        steps:
-            - name: Preview Changelog
-              uses: matrix-org/allchange@main
-              with:
-                  ghToken: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/pull_request.yaml

@@ -0,0 +1,96 @@
+name: Pull Request
+on:
+    pull_request_target:
+        types: [opened, edited, labeled, unlabeled, synchronize]
+    merge_group:
+        types: [checks_requested]
+    workflow_call:
+        secrets:
+            ELEMENT_BOT_TOKEN:
+                required: true
+concurrency: ${{ github.workflow }}-${{ github.event.pull_request.head.ref || github.head_ref || github.ref }}
+jobs:
+    changelog:
+        name: Preview Changelog
+        runs-on: ubuntu-latest
+        steps:
+            - uses: mheap/github-action-required-labels@5847eef68201219cf0a4643ea7be61e77837bbce # v5
+              if: github.event_name != 'merge_group'
+              with:
+                  labels: |
+                      X-Breaking-Change
+                      T-Deprecation
+                      T-Enhancement
+                      T-Defect
+                      T-Task
+                      Dependencies
+                  mode: minimum
+                  count: 1
+
+    prevent-blocked:
+        name: Prevent Blocked
+        runs-on: ubuntu-latest
+        permissions:
+            pull-requests: read
+        steps:
+            - name: Add notice
+              uses: actions/github-script@v7
+              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
+              if: github.event.pull_request.user.login != 'renovate[bot]'
+              uses: tspascoal/get-user-teams-membership@57e9f42acd78f4d0f496b3be4368fc5f62696662 # v3
+              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@v7
+              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@v7
+              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/workflows/release-drafter-workflow.yml

@@ -0,0 +1,89 @@
+# Workflow used by other workflows to generate draft releases.
+name: Release Drafter Reusable
+on:
+    workflow_call:
+        inputs:
+            include-changes:
+                description: Project to include changelog entries from in this release.
+                type: string
+                required: false
+concurrency: release-drafter-action
+jobs:
+    draft:
+        runs-on: ubuntu-latest
+        steps:
+            - name: 🧮 Checkout code
+              uses: actions/checkout@v4
+              with:
+                  ref: staging
+                  fetch-depth: 0
+
+            - uses: actions/setup-node@v4
+              with:
+                  node-version-file: package.json
+                  cache: "yarn"
+
+            - name: Install Deps
+              run: "yarn install --frozen-lockfile"
+
+            - uses: t3chguy/release-drafter@105e541c2c3d857f032bd522c0764694758fabad
+              id: draft-release
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+              with:
+                  disable-autolabeler: true
+
+            - name: Get actions scripts
+              uses: actions/checkout@v4
+              with:
+                  repository: matrix-org/matrix-js-sdk
+                  persist-credentials: false
+                  path: .action-repo
+                  sparse-checkout: |
+                      .github/actions
+                      scripts/release
+
+            - name: Ingest upstream changes
+              if: inputs.include-changes
+              uses: actions/github-script@v7
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+                  RELEASE_ID: ${{ steps.draft-release.outputs.id }}
+                  DEPENDENCY: ${{ inputs.include-changes }}
+                  VERSION: ${{ steps.draft-release.outputs.tag_name }}
+              with:
+                  retries: 3
+                  script: |
+                      const { RELEASE_ID: releaseId, DEPENDENCY, VERSION } = process.env;
+                      const { owner, repo } = context.repo;
+                      const script = require("./.action-repo/scripts/release/merge-release-notes.js");
+
+                      let deps = [];
+                      if (DEPENDENCY.includes("/")) {
+                          deps.push(DEPENDENCY.replace("$VERSION", VERSION))
+                      } else {
+                          const fromVersion = JSON.parse((await github.request(`https://raw.githubusercontent.com/${owner}/${repo}/master/package.json`)).data).dependencies[DEPENDENCY];
+                          const toVersion = require("./package.json").dependencies[DEPENDENCY];
+
+                          if (toVersion.endsWith("#develop")) {
+                              core.warning(`${DEPENDENCY} will be kept at ${fromVersion}`, { title: "Develop dependency found" });
+                          } else {
+                              deps.push([DEPENDENCY, fromVersion, toVersion]);
+                          }
+                      }
+
+                      if (deps.length) {
+                          const notes = await script({
+                              github,
+                              releaseId,
+                              dependencies: deps,
+                          });
+
+                          await github.rest.repos.updateRelease({
+                              owner,
+                              repo,
+                              release_id: releaseId,
+                              body: notes,
+                              tag_name: VERSION,
+                          });
+                      }

.github/workflows/release-drafter.yml

@@ -0,0 +1,13 @@
+# Generates the draft release for the js-sdk
+# Normally triggered whenever anything is merged to the staging branch, but
+# also has a workflow dispatch trigger in case it needs running manually due
+# to failures / workflow updates etc.
+name: Release Drafter
+on:
+    push:
+        branches: [staging]
+    workflow_dispatch: {}
+concurrency: ${{ github.workflow }}
+jobs:
+    draft:
+        uses: matrix-org/matrix-js-sdk/.github/workflows/release-drafter-workflow.yml@develop

.github/workflows/release-gitflow.yml

@@ -0,0 +1,85 @@
+# Gitflow merge-back master->develop
+name: Merge master -> develop
+on:
+    push:
+        branches: [master]
+    workflow_call:
+        secrets:
+            ELEMENT_BOT_TOKEN:
+                required: true
+        inputs:
+            dependencies:
+                description: List of dependencies to reset.
+                type: string
+                required: false
+concurrency: ${{ github.workflow }}
+jobs:
+    merge:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+              with:
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  fetch-depth: 0
+
+            - name: Get actions scripts
+              uses: actions/checkout@v4
+              with:
+                  repository: matrix-org/matrix-js-sdk
+                  persist-credentials: false
+                  path: .action-repo
+                  sparse-checkout: |
+                      scripts/release
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+
+            - name: Install Deps
+              run: "yarn install --frozen-lockfile"
+
+            - name: Set up git
+              run: |
+                  git config --global user.email "releases@riot.im"
+                  git config --global user.name "RiotRobot"
+
+            - name: Merge to develop
+              run: |
+                  git checkout develop
+                  git merge -X ours master
+
+            - name: Run post-merge-master script to revert package.json fields
+              run: ./.action-repo/scripts/release/post-merge-master.sh
+
+            - name: Reset dependencies
+              if: inputs.dependencies
+              run: |
+                  while IFS= read -r PACKAGE; do
+                      [ -z "$PACKAGE" ] && continue
+
+                      CURRENT_VERSION=$(cat package.json | jq -r .dependencies[\"$PACKAGE\"])
+                      echo "Current $PACKAGE version is $CURRENT_VERSION"
+
+                      if [ "$CURRENT_VERSION" == "null" ]
+                      then
+                          echo "Unable to find $PACKAGE in package.json"
+                          exit 1
+                      fi
+
+                      if [ "$CURRENT_VERSION" == "develop" ]
+                      then
+                          echo "Not updating dependency $PACKAGE"
+                          continue
+                      fi
+
+                      echo "Resetting $1 to develop branch..."
+                      yarn add "github:matrix-org/$PACKAGE#develop"
+                      git add -u
+                      git commit -m "Reset $PACKAGE back to develop branch"
+                  done <<< "$DEPENDENCIES"
+              env:
+                  DEPENDENCIES: ${{ inputs.dependencies }}
+                  FINAL: ${{ inputs.final }}
+
+            - name: Push changes
+              run: git push origin develop

.github/workflows/release-make.yml

@@ -0,0 +1,333 @@
+name: Release Make
+on:
+    workflow_call:
+        secrets:
+            ELEMENT_BOT_TOKEN:
+                required: true
+            NPM_TOKEN:
+                required: false
+            GPG_PASSPHRASE:
+                required: false
+            GPG_PRIVATE_KEY:
+                required: false
+        inputs:
+            final:
+                description: Make final release
+                required: true
+                default: false
+                type: boolean
+            npm:
+                description: Publish to npm
+                type: boolean
+                default: false
+            downstreams:
+                description: List of github projects (owner/repo) which should have their dependency bumped to the newly released version (in JSON string array string syntax)
+                type: string
+                required: false
+            gpg-fingerprint:
+                description: Fingerprint of the GPG key to use for signing the git tag and assets, if any.
+                type: string
+                required: false
+            asset-path:
+                description: |
+                    The path to the asset you want to upload, if any. You can use glob patterns here.
+                    Will be GPG signed and an `.asc` file included in the release artifacts if `gpg-fingerprint` is set.
+                type: string
+                required: false
+            expected-asset-count:
+                description: The number of expected assets, including signatures, excluding generated zip & tarball.
+                type: number
+                required: false
+jobs:
+    release:
+        name: Release
+        runs-on: ubuntu-latest
+        environment: Release
+        steps:
+            - name: Load GPG key
+              id: gpg
+              if: inputs.gpg-fingerprint
+              uses: crazy-max/ghaction-import-gpg@01dd5d3ca463c7f10f7f4f7b4f177225ac661ee4 # v6
+              with:
+                  gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
+                  passphrase: ${{ secrets.GPG_PASSPHRASE }}
+                  fingerprint: ${{ inputs.gpg-fingerprint }}
+
+            - name: Get draft release
+              id: draft-release
+              uses: cardinalby/git-get-release-action@5172c3a026600b1d459b117738c605fabc9e4e44 # v1
+              env:
+                  GITHUB_TOKEN: ${{ github.token }}
+              with:
+                  draft: true
+                  latest: true
+
+            - uses: actions/checkout@v4
+              with:
+                  ref: staging
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  fetch-depth: 0
+
+            - name: Get actions scripts
+              uses: actions/checkout@v4
+              with:
+                  repository: matrix-org/matrix-js-sdk
+                  persist-credentials: false
+                  path: .action-repo
+                  sparse-checkout: |
+                      .github/actions
+                      scripts/release
+
+            - name: Prepare variables
+              id: prepare
+              run: |
+                  echo "VERSION=$VERSION" >> $GITHUB_ENV
+
+                  HAS_DIST=0
+                  jq -e .scripts.dist package.json >/dev/null 2>&1 && HAS_DIST=1
+                  echo "has-dist-script=$HAS_DIST" >> $GITHUB_OUTPUT
+              env:
+                  VERSION: ${{ steps.draft-release.outputs.tag_name }}
+
+            - name: Finalise version
+              if: inputs.final
+              run: echo "VERSION=$(echo $VERSION | cut -d- -f1)" >> $GITHUB_ENV
+
+            - name: Check version number not in use
+              uses: actions/github-script@v7
+              with:
+                  script: |
+                      const { VERSION } = process.env;
+                      github.rest.repos.getReleaseByTag({
+                          owner: context.repo.owner,
+                          repo: context.repo.repo,
+                          tag: VERSION,
+                      }).then(() => {
+                          core.setFailed(`Version ${VERSION} already exists`);
+                      }).catch(() => {
+                        // This is fine, we expect there to not be any release with this version yet
+                      });
+
+            - name: Set up git
+              run: |
+                  git config --global user.email "releases@riot.im"
+                  git config --global user.name "RiotRobot"
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version-file: package.json
+
+            - name: Install dependencies
+              run: "yarn install --frozen-lockfile"
+
+            - name: Handle develop dependencies
+              run: |
+                  ret=0
+                  cat package.json | jq -r '.dependencies | to_entries | .[] | "\(.key) \(.value)"' | grep '#develop$' | while read -r dep ; do
+                      IFS=" "
+                      PACKAGE=${dep[0]}
+                      VERSION=${dep[1]}
+
+                      echo "::warning title=Develop dependency found::$DEPENDENCY will be kept at $VERSION"
+                      yarn upgrade "$PACKAGE@$VERSION" --exact
+                      git add -u
+                      git commit -m "Keep $PACKAGE at $VERSION"
+                  done
+
+            - name: Bump package.json version
+              run: yarn version --no-git-tag-version --new-version "${VERSION#v}"
+
+            - name: Add to CHANGELOG.md
+              if: inputs.final
+              run: |
+                  mv CHANGELOG.md CHANGELOG.md.old
+                  HEADER="Changes in [${VERSION#v}](https://github.com/${{ github.repository }}/releases/tag/$VERSION) ($(date '+%Y-%m-%d'))"
+
+                  {
+                      echo "$HEADER"
+                      printf '=%.0s' $(seq ${#HEADER})
+                      echo ""
+                      echo "$RELEASE_NOTES"
+                      echo ""
+                  } > CHANGELOG.md
+
+                  cat CHANGELOG.md.old >> CHANGELOG.md
+                  rm CHANGELOG.md.old
+                  git add CHANGELOG.md
+              env:
+                  RELEASE_NOTES: ${{ steps.draft-release.outputs.body }}
+
+            - name: Run pre-release script to update package.json fields
+              run: |
+                  ./.action-repo/scripts/release/pre-release.sh
+                  git add package.json
+
+            - name: Commit changes
+              run: git commit -m "$VERSION"
+
+            - name: Build assets
+              if: steps.prepare.outputs.has-dist-script == '1'
+              run: DIST_VERSION="$VERSION" yarn dist
+
+            - name: Upload release assets & signatures
+              if: inputs.asset-path
+              uses: ./.action-repo/.github/actions/upload-release-assets
+              with:
+                  gpg-fingerprint: ${{ inputs.gpg-fingerprint }}
+                  upload-url: ${{ steps.draft-release.outputs.upload_url }}
+                  asset-path: ${{ inputs.asset-path }}
+
+            - name: Create signed tag
+              if: inputs.gpg-fingerprint
+              run: |
+                  GIT_COMMITTER_EMAIL="$SIGNING_ID" GPG_TTY=$(tty) git tag -u "$SIGNING_ID" -m "Release $VERSION" "$VERSION"
+              env:
+                  SIGNING_ID: ${{ steps.gpg.outputs.email }}
+
+            - name: Generate & upload tarball signature
+              if: inputs.gpg-fingerprint
+              uses: ./.action-repo/.github/actions/sign-release-tarball
+              with:
+                  gpg-fingerprint: ${{ inputs.gpg-fingerprint }}
+                  upload-url: ${{ steps.draft-release.outputs.upload_url }}
+
+            # We defer pushing changes until after the release assets are built,
+            # signed & uploaded to improve the atomicity of this action.
+            - name: Push changes to staging
+              run: |
+                  git push origin staging $TAG
+                  git reset --hard
+              env:
+                  TAG: ${{ inputs.gpg-fingerprint && env.VERSION || '' }}
+
+            - name: Validate tarball signature
+              if: inputs.gpg-fingerprint
+              run: |
+                  wget https://github.com/$GITHUB_REPOSITORY/archive/refs/tags/$VERSION.tar.gz
+                  gpg --verify "$VERSION.tar.gz.asc" "$VERSION.tar.gz"
+
+            - name: Validate release has expected assets
+              if: inputs.expected-asset-count
+              uses: actions/github-script@v7
+              env:
+                  RELEASE_ID: ${{ steps.draft-release.outputs.id }}
+                  EXPECTED_ASSET_COUNT: ${{ inputs.expected-asset-count }}
+              with:
+                  retries: 3
+                  script: |
+                      const { RELEASE_ID: release_id, EXPECTED_ASSET_COUNT } = process.env;
+                      const { owner, repo } = context.repo;
+
+                      const { data: release } = await github.rest.repos.getRelease({
+                          owner,
+                          repo,
+                          release_id,
+                      });
+
+                      if (release.assets.length !== parseInt(EXPECTED_ASSET_COUNT, 10)) {
+                          core.setFailed(`Found ${release.assets.length} assets but expected ${EXPECTED_ASSET_COUNT}`);
+                      }
+
+            - name: Merge to master
+              if: inputs.final
+              run: |
+                  git checkout master
+                  git merge -X theirs staging
+                  git push origin master
+
+            - name: Publish release
+              uses: actions/github-script@v7
+              env:
+                  RELEASE_ID: ${{ steps.draft-release.outputs.id }}
+                  FINAL: ${{ inputs.final }}
+              with:
+                  retries: 3
+                  github-token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  script: |
+                      const { RELEASE_ID: release_id, RELEASE_NOTES, VERSION, FINAL } = process.env;
+                      const { owner, repo } = context.repo;
+
+                      const opts = {
+                          owner,
+                          repo,
+                          release_id,
+                          tag_name: VERSION,
+                          name: VERSION,
+                          draft: false,
+                          body: RELEASE_NOTES,
+                      };
+
+                      if (FINAL == "true") {
+                          opts.prerelease = false;
+                          opts.make_latest = true;
+                      }
+
+                      github.rest.repos.updateRelease(opts);
+
+    npm:
+        name: Publish to npm
+        needs: release
+        if: inputs.npm
+        uses: matrix-org/matrix-js-sdk/.github/workflows/release-npm.yml@develop
+        secrets:
+            NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+    post-release:
+        name: Post release steps
+        needs: release
+        runs-on: ubuntu-latest
+        steps:
+            - id: repository
+              run: echo "REPO=${GITHUB_REPOSITORY#*/}" >> $GITHUB_OUTPUT
+
+            - name: Advance release blocker labels
+              uses: garganshu/github-label-updater@3770d15ebfed2fe2cb06a241047bc340f774a7d1 # v1.0.0
+              with:
+                  owner: ${{ github.repository_owner }}
+                  repo: ${{ steps.repository.outputs.REPO }}
+                  token: ${{ secrets.GITHUB_TOKEN }}
+                  filter-labels: X-Upcoming-Release-Blocker
+                  remove-labels: X-Upcoming-Release-Blocker
+                  add-labels: X-Release-Blocker
+
+    #            - name: Wait for master->develop gitflow merge
+    #              if: inputs.final
+    #              uses: t3chguy/wait-on-check-action@18541021811b56544d90e0f073401c2b99e249d6 # fork
+    #              with:
+    #                  ref: master
+    #                  repo-token: ${{ secrets.GITHUB_TOKEN }}
+    #                  wait-interval: 10
+    #                  check-name: merge
+    #                  allowed-conclusions: success
+
+    bump-downstreams:
+        name: Update npm dependency in downstream projects
+        needs: npm
+        runs-on: ubuntu-latest
+        if: inputs.downstreams
+        strategy:
+            matrix:
+                repo: ${{ fromJSON(inputs.downstreams) }}
+        steps:
+            - uses: actions/checkout@v4
+              with:
+                  repository: ${{ matrix.repo }}
+                  ref: staging
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version: "lts/*"
+
+            - name: Bump dependency
+              env:
+                  DEPENDENCY: ${{ needs.npm.outputs.id }}
+              run: |
+                  git config --global user.email "releases@riot.im"
+                  git config --global user.name "RiotRobot"
+                  yarn upgrade "$DEPENDENCY" --exact
+                  git add package.json yarn.lock
+                  git commit -am"Upgrade dependency to $DEPENDENCY"
+                  git push origin staging

.github/workflows/release-npm.yml

@@ -0,0 +1,47 @@
+name: Publish to npm
+on:
+    workflow_call:
+        secrets:
+            NPM_TOKEN:
+                required: true
+        outputs:
+            id:
+                description: "The npm package@version string we published"
+                value: ${{ jobs.npm.outputs.id }}
+jobs:
+    npm:
+        name: Publish to npm
+        runs-on: ubuntu-latest
+        outputs:
+            id: ${{ steps.npm-publish.outputs.id }}
+        steps:
+            - name: 🧮 Checkout code
+              uses: actions/checkout@v4
+              with:
+                  ref: staging
+
+            - name: 🔧 Yarn cache
+              uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  registry-url: "https://registry.npmjs.org"
+                  node-version-file: package.json
+
+            - name: 🔨 Install dependencies
+              run: "yarn install --frozen-lockfile"
+
+            - name: 🚀 Publish to npm
+              id: npm-publish
+              uses: JS-DevTools/npm-publish@19c28f1ef146469e409470805ea4279d47c3d35c # v3.1.1
+              with:
+                  token: ${{ secrets.NPM_TOKEN }}
+                  access: public
+                  tag: next
+                  ignore-scripts: false
+
+            - name: 🎖️ Add `latest` dist-tag to final releases
+              if: steps.npm-publish.outputs.id && !contains(steps.npm-publish.outputs.id, '-rc.')
+              run: npm dist-tag add "$release" latest
+              env:
+                  NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+                  release: ${{ steps.npm-publish.outputs.id }}

.github/workflows/release.yml

@@ -0,0 +1,73 @@
+name: Release Process
+on:
+    workflow_dispatch:
+        inputs:
+            mode:
+                description: What type of release
+                required: true
+                default: rc
+                type: choice
+                options:
+                    - rc
+                    - final
+            docs:
+                description: Publish docs
+                required: true
+                type: boolean
+                default: true
+            npm:
+                description: Publish to npm
+                required: true
+                type: boolean
+                default: true
+concurrency: ${{ github.workflow }}
+jobs:
+    release:
+        uses: matrix-org/matrix-js-sdk/.github/workflows/release-make.yml@develop
+        secrets: inherit
+        with:
+            final: ${{ inputs.mode == 'final' }}
+            npm: ${{ inputs.npm }}
+            downstreams: '["matrix-org/matrix-react-sdk", "element-hq/element-web"]'
+
+    docs:
+        name: Publish Documentation
+        needs: release
+        if: inputs.docs
+        runs-on: ubuntu-latest
+        steps:
+            - name: 🧮 Checkout code
+              uses: actions/checkout@v4
+
+            - name: 🔧 Yarn cache
+              uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version-file: package.json
+
+            - name: 🔨 Install dependencies
+              run: "yarn install --frozen-lockfile"
+
+            - name: 📖 Generate docs
+              run: yarn gendoc
+
+            - name: Upload artifact
+              uses: actions/upload-pages-artifact@v3
+              with:
+                  path: _docs
+
+    docs-deploy:
+        environment:
+            name: github-pages
+            url: ${{ steps.deployment.outputs.page_url }}
+        runs-on: ubuntu-latest
+        needs: docs
+        # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+        permissions:
+            contents: read
+            pages: write
+            id-token: write
+        steps:
+            - name: Deploy to GitHub Pages
+              id: deployment
+              uses: actions/deploy-pages@v4

.github/workflows/sonarcloud.yml

@@ -0,0 +1,85 @@
+# 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
+            ELEMENT_BOT_TOKEN:
+                required: true
+        inputs:
+            sharded:
+                type: boolean
+                required: false
+                description: "Whether to combine multiple LCOV and jest-sonar-report files in coverage artifact"
+jobs:
+    sonarqube:
+        runs-on: ubuntu-latest
+        if: |
+            github.event.workflow_run.conclusion == 'success' &&
+            github.event.workflow_run.event != 'merge_group'
+        steps:
+            # We create the status here and then update it to success/failure in the `report` stage
+            # This provides an easy link to this workflow_run from the PR before Sonarcloud is done.
+            - uses: Sibz/github-status-action@071b5370da85afbb16637d6eed8524a06bc2053e # 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: "🧮 Checkout code"
+              uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4
+              with:
+                  repository: ${{ github.event.workflow_run.head_repository.full_name }}
+                  ref: ${{ github.event.workflow_run.head_branch }} # checkout commit that triggered this workflow
+                  fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis
+
+            - name: 📥 Download artifact
+              uses: actions/download-artifact@v4
+              if: ${{ !inputs.sharded }}
+              with:
+                  github-token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  run-id: ${{ github.event.workflow_run.id }}
+                  name: coverage
+                  path: coverage
+            - name: 📥 Download sharded artifacts
+              uses: actions/download-artifact@v4
+              if: inputs.sharded
+              with:
+                  github-token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  run-id: ${{ github.event.workflow_run.id }}
+                  pattern: coverage-*
+                  path: coverage
+                  merge-multiple: true
+
+            - id: extra_args
+              run: |
+                  coverage=$(find coverage -type f -name '*lcov.info' -printf '%h/%f,' | tr -d '\r\n' | sed 's/,$//g')
+                  echo "sonar.javascript.lcov.reportPaths=$coverage" >> sonar-project.properties
+                  reports=$(find coverage -type f -name 'jest-sonar-report*.xml' -printf '%h/%f,' | tr -d '\r\n' | sed 's/,$//g')
+                  echo "sonar.testExecutionReportPaths=$reports" >> sonar-project.properties
+
+            - name: "🩻 SonarCloud Scan"
+              id: sonarcloud
+              uses: matrix-org/sonarcloud-workflow-action@v3.2
+              # 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:
+                  skip_checkout: true
+                  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 }}
+
+            - uses: Sibz/github-status-action@071b5370da85afbb16637d6eed8524a06bc2053e # 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

@@ -0,0 +1,19 @@
+name: SonarQube
+on:
+    workflow_run:
+        workflows: ["Tests"]
+        types:
+            - completed
+concurrency:
+    group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch }}
+    cancel-in-progress: true
+jobs:
+    sonarqube:
+        name: 🩻 SonarQube
+        if: github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.event != 'merge_group'
+        uses: matrix-org/matrix-js-sdk/.github/workflows/sonarcloud.yml@develop
+        secrets:
+            SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+            ELEMENT_BOT_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}
+        with:
+            sharded: true

.github/workflows/static_analysis.yml

@@ -0,0 +1,113 @@
+name: Static Analysis
+on:
+    pull_request: {}
+    merge_group:
+        types: [checks_requested]
+    push:
+        branches: [develop, master]
+concurrency:
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
+jobs:
+    ts_lint:
+        name: "Typescript Syntax Check"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version-file: package.json
+
+            - name: Install Deps
+              run: "yarn install"
+
+            - name: Typecheck
+              run: "yarn run lint:types"
+
+            - name: Switch js-sdk to release mode
+              run: |
+                  scripts/switch_package_to_release.js
+                  yarn install
+                  yarn run build:compile
+                  yarn run build:types
+
+            - name: Typecheck (release mode)
+              run: "yarn run lint:types"
+
+    js_lint:
+        name: "ESLint"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version-file: package.json
+
+            - name: Install Deps
+              run: "yarn install"
+
+            - name: Run Linter
+              run: "yarn run lint:js"
+
+    workflow_lint:
+        name: "Workflow Lint"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version-file: package.json
+
+            - name: Install Deps
+              run: "yarn install --frozen-lockfile"
+
+            - name: Run Linter
+              run: "yarn lint:workflows"
+
+    docs:
+        name: "JSDoc Checker"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version-file: package.json
+
+            - name: Install Deps
+              run: "yarn install"
+
+            - name: Generate Docs
+              run: "yarn run gendoc --treatWarningsAsErrors --suppressCommentWarningsInDeclarationFiles"
+
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v4
+              with:
+                  name: docs
+                  path: _docs
+                  # We'll only use this in a workflow_run, then we're done with it
+                  retention-days: 1
+
+    analyse_dead_code:
+        name: "Analyse Dead Code"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version-file: package.json
+
+            - name: Install Deps
+              run: "yarn install --frozen-lockfile"
+
+            - name: Run linter
+              run: "yarn run lint:knip"

.github/workflows/sync-labels.yml

@@ -0,0 +1,21 @@
+name: Sync labels
+on:
+    workflow_dispatch: {}
+    schedule:
+        - cron: "0 1 * * *" # 1am every day
+    push:
+        branches:
+            - develop
+        paths:
+            - .github/labels.yml
+jobs:
+    sync-labels:
+        uses: element-hq/element-meta/.github/workflows/sync-labels.yml@develop
+        with:
+            LABELS: |
+                element-hq/element-meta
+                .github/labels.yml
+            DELETE: true
+            WET: true
+        secrets:
+            ELEMENT_BOT_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}

.github/workflows/tests.yml

@@ -0,0 +1,113 @@
+name: Tests
+on:
+    pull_request: {}
+    merge_group:
+        types: [checks_requested]
+    push:
+        branches: [develop, master]
+concurrency:
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
+env:
+    ENABLE_COVERAGE: ${{ github.event_name != 'merge_group' }}
+jobs:
+    jest:
+        name: "Jest [${{ matrix.specs }}] (Node ${{ matrix.node == '*' && 'latest' || matrix.node }})"
+        runs-on: ubuntu-latest
+        timeout-minutes: 10
+        strategy:
+            matrix:
+                specs: [integ, unit]
+                node: ["lts/*", 21, 22]
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Setup Node
+              id: setupNode
+              uses: actions/setup-node@v4
+              with:
+                  cache: "yarn"
+                  node-version: ${{ matrix.node }}
+
+            - name: Install dependencies
+              run: "yarn install"
+
+            - name: Get number of CPU cores
+              id: cpu-cores
+              uses: SimenB/github-actions-cpu-cores@97ba232459a8e02ff6121db9362b09661c875ab8 # v2
+
+            - name: Run tests
+              run: |
+                  yarn test \
+                      --coverage=${{ env.ENABLE_COVERAGE }} \
+                      --ci \
+                      --max-workers ${{ steps.cpu-cores.outputs.count }} \
+                      ./spec/${{ matrix.specs }}
+              env:
+                  JEST_SONAR_UNIQUE_OUTPUT_NAME: true
+
+                  # tell jest to use coloured output
+                  FORCE_COLOR: true
+
+            - name: Move coverage files into place
+              if: env.ENABLE_COVERAGE == 'true'
+              run: mv coverage/lcov.info coverage/${{ steps.setupNode.outputs.node-version }}-${{ matrix.specs }}.lcov.info
+
+            - name: Upload Artifact
+              if: env.ENABLE_COVERAGE == 'true'
+              uses: actions/upload-artifact@v4
+              with:
+                  name: coverage-${{ matrix.specs }}-${{ matrix.node == 'lts/*' && 'lts' || matrix.node }}
+                  path: |
+                      coverage
+                      !coverage/lcov-report
+
+    matrix-react-sdk:
+        name: Downstream test matrix-react-sdk
+        if: github.event_name == 'merge_group'
+        uses: matrix-org/matrix-react-sdk/.github/workflows/tests.yml@develop
+        with:
+            disable_coverage: true
+            matrix-js-sdk-sha: ${{ github.sha }}
+
+    complement-crypto:
+        name: "Run Complement Crypto tests"
+        if: github.event_name == 'merge_group'
+        uses: matrix-org/complement-crypto/.github/workflows/single_sdk_tests.yml@main
+        with:
+            use_js_sdk: "."
+
+    # we need this so the job is reported properly when run in a merge queue
+    downstream-complement-crypto:
+        name: Downstream Complement Crypto tests
+        runs-on: ubuntu-latest
+        if: always()
+        needs:
+            - complement-crypto
+        steps:
+            - if: needs.complement-crypto.result != 'skipped' && needs.complement-crypto.result != 'success'
+              run: exit 1
+
+    # Hook for branch protection to skip downstream testing outside of merge queues
+    # and skip sonarcloud coverage within merge queues
+    downstream:
+        name: Downstream tests
+        runs-on: ubuntu-latest
+        if: always()
+        needs:
+            - matrix-react-sdk
+        steps:
+            - name: Skip SonarCloud on merge queues
+              if: env.ENABLE_COVERAGE == 'false'
+              uses: Sibz/github-status-action@071b5370da85afbb16637d6eed8524a06bc2053e # v1
+              with:
+                  authToken: ${{ secrets.GITHUB_TOKEN }}
+                  state: success
+                  description: SonarCloud skipped
+                  context: SonarCloud Code Analysis
+                  sha: ${{ github.sha }}
+                  target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}
+
+            - if: needs.matrix-react-sdk.result != 'skipped' && needs.matrix-react-sdk.result != 'success'
+              run: exit 1

.github/workflows/triage-incoming.yml

@@ -0,0 +1,14 @@
+name: Move new issues into Issue triage board
+
+on:
+    issues:
+        types: [opened]
+
+jobs:
+    automate-project-columns-next:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/add-to-project@main
+              with:
+                  project-url: https://github.com/orgs/element-hq/projects/120
+                  github-token: ${{ secrets.ELEMENT_BOT_TOKEN }}

.github/workflows/triage-labelled.yml

@@ -0,0 +1,11 @@
+name: Move labelled issues to correct projects
+
+on:
+    issues:
+        types: [labeled]
+
+jobs:
+    call-triage-labelled:
+        uses: element-hq/element-web/.github/workflows/triage-labelled.yml@develop
+        secrets:
+            ELEMENT_BOT_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}

.gitignore

@@ -1,5 +1,5 @@
-/.jsdocbuild
-/.jsdoc
+/_docs
+.DS_Store
 
 node_modules
 /.npmrc
@@ -19,3 +19,4 @@ out
 
 .vscode
 .vscode/
+.idea/

.husky/pre-commit

@@ -0,0 +1,3 @@
+#!/usr/bin/env sh
+
+npx lint-staged

.istanbul.yml

@@ -1,2 +0,0 @@
-instrumentation:
-  compact: false

.lintstagedrc

@@ -0,0 +1,4 @@
+{
+    "*.(ts|tsx)": ["eslint --fix", "prettier --write"],
+    "*.(py|md|yaml)": ["prettier --write"]
+}

.prettierignore

@@ -0,0 +1,30 @@
+/_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
+
+# These files are also autogenerated
+/spec/test-utils/test-data/index.ts
+/spec/test-utils/test_indexeddb_cryptostore_dump/dump.json

.prettierrc.js

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

CONTRIBUTING.md

@@ -1,200 +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.
- * Include both **before** and **after** screenshots to easily compare and discuss
-   what's changing.
- * Include a step-by-step testing strategy so that a reviewer can check out the
-   code locally and easily get to the point of testing your change.
- * Add comments to the diff for the reviewer that might help them to understand
-   why the change is necessary or how they might better understand and review it.
-
-Things that should *not* go into your PR description:
- * Any information on how the code works or why you chose to do it the way
-   you did. If this isn't obvious from your code, you haven't written enough
-   comments.
-
-We rely on information in pull request to populate the information that goes
-into the changelogs our users see, both for the JS SDK itself and also for some
-projects based on it. This is picked up from both labels on the pull request and
-the `Notes:` annotation in the description. By default, the PR title will be
-used for the changelog entry, but you can specify more options, as follows.
-
-To add a longer, more detailed description of the change for the changelog:
-
-
-*Fix llama herding bug*
-
-```
-Notes: Fix a bug (https://github.com/matrix-org/notaproject/issues/123) where the 'Herd' button would not herd more than 8 Llamas if the moon was in the waxing gibbous phase
-```
-
-For some PRs, it's not useful to have an entry in the user-facing changelog (this is
-the default for PRs labelled with `T-Task`):
-
-*Remove outdated comment from `Ungulates.ts`*
-```
-Notes: none
-```
-
-Sometimes, you're fixing a bug in a downstream project, in which case you want
-an entry in that project's changelog. You can do that too:
-
-*Fix another herding bug*
-```
-Notes: Fix a bug where the `herd()` function would only work on Tuesdays
-element-web notes: Fix a bug where the 'Herd' button only worked on Tuesdays
-```
-
-This example is for Element Web. You can specify:
- * matrix-react-sdk
- * element-web
- * element-desktop
-
-If your PR introduces a breaking change, use the `Notes` section in the same
-way, additionally adding the `X-Breaking-Change` label (see below). There's no need
-to specify in the notes that it's a breaking change - this will be added
-automatically based on the label - but remember to tell the developer how to
-migrate:
-
-*Remove legacy class*
-
-```
-Notes: Remove legacy `Camelopard` class. `Giraffe` should be used instead.
-```
-
-Other metadata can be added using labels.
- * `X-Breaking-Change`: A breaking change - adding this label will mean the change causes a *major* version bump.
- * `T-Enhancement`: A new feature - adding this label will mean the change causes a *minor* version bump.
- * `T-Defect`: A bug fix (in either code or docs).
- * `T-Task`: No user-facing changes, eg. code comments, CI fixes, refactors or tests. Won't have a changelog entry unless you specify one.
-
-If you don't have permission to add labels, your PR reviewer(s) can work with you
-to add them: ask in the PR description or comments.
-
-We use continuous integration, and all pull requests get automatically tested:
-if your change breaks the build, then the PR will show that there are failed
-checks, so please check back after a few minutes.
-
-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
-```
+matrix-js-sdk follows the same pattern as https://github.com/vector-im/element-web/blob/develop/CONTRIBUTING.md

README.md

@@ -1,46 +1,41 @@
-Matrix Javascript SDK
-=====================
+[![npm](https://img.shields.io/npm/v/matrix-js-sdk)](https://www.npmjs.com/package/matrix-js-sdk)
+![Tests](https://github.com/matrix-org/matrix-js-sdk/actions/workflows/tests.yml/badge.svg)
+![Static Analysis](https://github.com/matrix-org/matrix-js-sdk/actions/workflows/static_analysis.yml/badge.svg)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
+[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=coverage)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
+[![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)
 
-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.
+# Matrix JavaScript SDK
 
-Quickstart
-==========
+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.
 
-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
-include libolm to enable end-to-end-encryption.
+#### Minimum Matrix server version: v1.1
 
-The browser bundle supports recent versions of browsers. Typically this is ES2015
-or `> 0.5%, last 2 versions, Firefox ESR, not dead` if using 
-[browserlists](https://github.com/browserslist/browserslist).
+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.
 
-Please check [the working browser example](examples/browser) for more information.
+# Quickstart
 
-In Node.js
-----------
+> [!IMPORTANT]
+> Servers may require or use authenticated endpoints for media (images, files, avatars, etc). See the
+> [Authenticated Media](#authenticated-media) section for information on how to enable support for this.
 
-Ensure you have the latest LTS version of Node.js installed.
-
-This SDK targets Node 10 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.
-
-Using `yarn` instead of `npm` is recommended. Please see the Yarn [install guide](https://classic.yarnpkg.com/en/docs/install) 
+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
@@ -49,14 +44,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(ClientEvent.sync, function (state, prevState, res) {
+    if (state === "PREPARED") {
         console.log("prepared");
     } else {
         console.log(state);
@@ -69,8 +64,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);
@@ -80,11 +75,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(RoomEvent.Timeline, function (event, room, toStartOfTimeline) {
+    if (event.getType() !== "m.room.message") {
+        return; // only use messages
+    }
+    console.log(event.event.content.body);
 });
 ```
 
@@ -92,156 +87,165 @@ 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?
-----------------------
+## Authenticated media
+
+Servers supporting [MSC3916](https://github.com/matrix-org/matrix-spec-proposals/pull/3916) (Matrix 1.11) will require clients, like
+yours, to include an `Authorization` header when `/download`ing or `/thumbnail`ing media. For NodeJS environments this
+may be as easy as the following code snippet, though web browsers may need to use [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API)
+to append the header when using the endpoints in `<img />` elements and similar.
+
+```javascript
+const downloadUrl = client.mxcUrlToHttp(
+    /*mxcUrl=*/ "mxc://example.org/abc123", // the MXC URI to download/thumbnail, typically from an event or profile
+    /*width=*/ undefined, // part of the thumbnail API. Use as required.
+    /*height=*/ undefined, // part of the thumbnail API. Use as required.
+    /*resizeMethod=*/ undefined, // part of the thumbnail API. Use as required.
+    /*allowDirectLinks=*/ false, // should generally be left `false`.
+    /*allowRedirects=*/ true, // implied supported with authentication
+    /*useAuthentication=*/ true, // the flag we're after in this example
+);
+const img = await fetch(downloadUrl, {
+    headers: {
+        Authorization: `Bearer ${client.getAccessToken()}`,
+    },
+});
+// Do something with `img`.
+```
+
+> [!WARNING]
+> In future the js-sdk will _only_ return authentication-required URLs, mandating population of the `Authorization` header.
+
+## 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.
 
-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)
+-   Handles syncing (via `/sync`)
+-   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.
 
-Usage
-=====
+# Usage
 
+## Supported platforms
 
-Conventions
------------
+`matrix-js-sdk` can be used in either Node.js applications (ensure you have the latest LTS version of Node.js installed),
+or in browser applications, via a bundler such as Webpack or Vite.
 
-### Emitted events
+You can also use the sdk with [Deno](https://deno.land/) (`import npm:matrix-js-sdk`) but its not officialy supported.
 
-The SDK will emit events using an ``EventEmitter``. It also
-emits object models (e.g. ``Rooms``, ``RoomMembers``) when they
-are updated.
+## Emitted events
+
+The SDK raises notifications to the application using
+[`EventEmitter`s](https://nodejs.org/api/events.html#class-eventemitter). The `MatrixClient` itself
+implements `EventEmitter`, as do many of the high-level abstractions such as `Room` and `RoomMember`.
 
 ```javascript
-  // Listen for low-level MatrixEvents
-  client.on("event", function(event) {
+// Listen for low-level MatrixEvents
+client.on(ClientEvent.Event, function (event) {
     console.log(event.getType());
-  });
+});
 
-  // Listen for typing changes
-  client.on("RoomMember.typing", function(event, member) {
+// Listen for typing changes
+client.on(RoomMemberEvent.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
+## Entry points
 
-Most of the methods in the SDK are asynchronous: they do not directly return a
-result, but instead return a [Promise](http://documentup.com/kriskowal/q/)
-which will be fulfilled in the future.
+As well as the primary entry point (`matrix-js-sdk`), there are several other entry points which may be useful:
 
-The typical usage is something like:
+| Entry point                    | Description                                                                                         |
+| ------------------------------ | --------------------------------------------------------------------------------------------------- |
+| `matrix-js-sdk`                | Primary entry point. High-level functionality, and lots of historical clutter in need of a cleanup. |
+| `matrix-js-sdk/lib/crypto-api` | Cryptography functionality.                                                                         |
+| `matrix-js-sdk/lib/types`      | Low-level types, reflecting data structures defined in the Matrix spec.                             |
+| `matrix-js-sdk/lib/testing`    | Test utilities, which may be useful in test code but should not be used in production code.         |
 
-```javascript
-  matrixClient.someMethod(arg1, arg2).then(function(result) {
-    ...
-  });
-```
+## Examples
 
-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);
-```
-
-The main thing to note is that it is problematic to discard the result of a
-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
-removed from existing methods.
-
-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:
+core functionality of the SDK. These examples assume the SDK is set up 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(RoomEvent.MyMembership, function (room, membership, prevMembership) {
+    if (membership === KnownMembership.Invite) {
+        matrixClient.joinRoom(room.roomId).then(function () {
+            console.log("Auto-joined %s", room.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(RoomEvent.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?
@@ -253,27 +257,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(RoomStateEvent.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
   =======
@@ -283,36 +284,37 @@ 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
+
+**This section is outdated.** Use of `libolm` is deprecated and we are replacing it with support
+from the matrix-rust-sdk (https://github.com/element-hq/element-web/issues/21972).
 
 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 ``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
@@ -324,46 +326,48 @@ 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:
 
-To build a browser version from scratch when developing::
 ```
  $ yarn build
 ```
 
-To run tests (Jasmine)::
+To run tests (Jest):
+
 ```
  $ yarn test
 ```
 
 To run linting:
+
 ```
  $ yarn lint
 ```

babel.config.cjs

@@ -0,0 +1,26 @@
+module.exports = {
+    sourceMaps: true,
+    presets: [
+        [
+            "@babel/preset-env",
+            {
+                targets: {
+                    esmodules: true,
+                },
+                // We want to output ES modules for the final build (mostly to ensure that
+                // async imports work correctly). However, jest doesn't support ES modules very
+                // well yet (see https://github.com/jestjs/jest/issues/9430), so we use commonjs
+                // when testing.
+                modules: process.env.NODE_ENV === "test" ? "commonjs" : false,
+            },
+        ],
+        "@babel/preset-typescript",
+    ],
+    plugins: [
+        "@babel/plugin-transform-numeric-separator",
+        "@babel/plugin-transform-class-properties",
+        "@babel/plugin-transform-object-rest-spread",
+        "@babel/plugin-syntax-dynamic-import",
+        "@babel/plugin-transform-runtime",
+    ],
+};

docs/SUMMARY.md

@@ -0,0 +1,8 @@
+# Summary
+
+-   [Introduction](../README.md)
+
+# Deep dive
+
+-   [Storage notes](storage-notes.md)
+-   [Unverified devices](warning-on-unverified-devices.md)

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

docs/warning-on-unverified-devices.md

@@ -1,31 +1,29 @@
 Random notes from Matthew on the two possible approaches for warning users about unexpected
 unverified devices popping up in their rooms....
 
-Original idea...
-================
+# Original idea...
 
 Warn when an existing user adds an unknown device to a room.
 
 Warn when a user joins the room with unverified or unknown devices.
 
 Warn when you initial sync if the room has any unverified devices in it.
- ^ this is good enough if we're doing local storage.
- OR, better:
+^ this is good enough if we're doing local storage.
+OR, better:
 Warn when you initial sync if the room has any new undefined devices since you were last there.
- => This means persisting the rooms that devices are in, across initial syncs.
+=> This means persisting the rooms that devices are in, across initial syncs.
 
-
-Updated idea...
-===============
+# Updated idea...
 
 Warn when the user tries to send a message:
-  - If the room has unverified devices which the user has not yet been told about in the context of this room
-    ...or in the context of this user?  currently all verification is per-user, not per-room.
+
+-   If the room has unverified devices which the user has not yet been told about in the context of this room
+    ...or in the context of this user? currently all verification is per-user, not per-room.
     ...this should be good enough.
 
-  - so track whether we have warned the user or not about unverified devices - blocked, unverified, verified, unverified_warned.
+-   so track whether we have warned the user or not about unverified devices - blocked, unverified, verified, unverified_warned.
     throw an error when trying to encrypt if there are pure unverified devices there
     app will have to search for the devices which are pure unverified to warn about them - have to do this from MembersList anyway?
-      - or megolm could warn which devices are causing the problems.
+    -   or megolm could warn which devices are causing the problems.
 
-Why do we wait to establish outbound sessions?  It just makes a horrible pause when we first try to send a message... but could otherwise unnecessarily consume resources?
+Why do we wait to establish outbound sessions? It just makes a horrible pause when we first try to send a message... but could otherwise unnecessarily consume resources?

examples/browser/README.md

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

examples/browser/browserTest.js

@@ -1,13 +0,0 @@
-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;
-    }
-    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");
-    result.innerHTML = "<p>The SDK appears to be working correctly.</p>";
-});

examples/browser/index.html

@@ -1,18 +0,0 @@
-<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>
-</html>

examples/browser/lib/matrix.js

@@ -1 +0,0 @@
-../../../dist/browser-matrix.js

examples/crypto-browser/lib/.gitignore

@@ -1,2 +0,0 @@
-olm.js
-olm.wasm

examples/crypto-browser/lib/matrix.js

@@ -1 +0,0 @@
-../../../dist/browser-matrix.js

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

@@ -1,59 +0,0 @@
-<!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>
-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>
-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>
-aliceMatrixClient = await importMatrixClient(EXPORTED_DATA, ACCESS_TOKEN);
-            </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>

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

@@ -1,122 +0,0 @@
-if (!Olm) {
-    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';
-
-// useful to create new usernames
-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 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(),
-    });
-
-    extendMatrixClient(matrixClient);
-
-    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(),
-    });
-
-    extendMatrixClient(matrixClient);
-
-    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()) {
-            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' })
-        }
-    });
-
-    matrixClient.onDecryptedMessage = message => {
-        console.log('Got encrypted message: ', 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(event);
-        }
-    });
-  
-    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,
-        );
-
-        // Marking all devices as verified
-        let room = this.getRoom(roomId);
-        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);
-          }
-        }
-
-        return roomId;
-    }
-
-    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") {
+            if (viewingRoom.getMember(myUserId).membership === KnownMembership.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.substr(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.substr(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,12 @@
 {
-  "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",
+    "author": "",
+    "license": "Apache 2.0",
+    "dependencies": {
+        "cli-color": "^1.0.0",
+        "matrix-js-sdk": "^32.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

@@ -1,16 +1,17 @@
 console.log("Loading browser sdk");
-var BASE_URL = "https://matrix.org";
-var TOKEN = "accesstokengoeshere";
-var USER_ID = "@username:localhost";
-var ROOM_ID = "!room:id";
+const BASE_URL = "https://matrix.org";
+const TOKEN = "accesstokengoeshere";
+const USER_ID = "@username:localhost";
+const ROOM_ID = "!room:id";
+const DEVICE_ID = "some_device_id";
 
-
-var client = matrixcs.createClient({
+const client = matrixcs.createClient({
     baseUrl: BASE_URL,
     accessToken: TOKEN,
-    userId: USER_ID
+    userId: USER_ID,
+    deviceId: DEVICE_ID,
 });
-var call;
+let call;
 
 function disableButtons(place, answer, hangup) {
     document.getElementById("hangup").disabled = hangup;
@@ -19,19 +20,17 @@ function disableButtons(place, answer, hangup) {
 }
 
 function addListeners(call) {
-    var lastError = "";
-    call.on("hangup", function() {
+    let lastError = "";
+    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());
 
@@ -50,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();
@@ -84,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();
@@ -99,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>

jest.config.ts

@@ -0,0 +1,47 @@
+/* Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import type { Config } from "jest";
+import { env } from "process";
+
+const config: Config = {
+    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",
+
+    // Always print out a summary if there are any failing tests. Normally
+    // a summary is only printed if there are more than 20 test *suites*.
+    reporters: [["default", { summaryThreshold: 0 }]],
+};
+
+// if we're running under GHA, enable the GHA reporter
+if (env["GITHUB_ACTIONS"] !== undefined) {
+    const reporters: Config["reporters"] = [
+        ["github-actions", { silent: false }],
+        // as above: always show a summary if there were any failing tests.
+        ["summary", { summaryThreshold: 0 }],
+    ];
+
+    // if we're running against the develop branch, also enable the slow test reporter
+    if (env["GITHUB_REF"] == "refs/heads/develop") {
+        reporters.push("<rootDir>/spec/slowReporter.js");
+    }
+    config.reporters = reporters;
+}
+
+export default config;

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
-  }
-}

knip.ts

@@ -0,0 +1,36 @@
+import { KnipConfig } from "knip";
+
+export default {
+    entry: [
+        "src/index.ts",
+        "src/types.ts",
+        "src/browser-index.ts",
+        "src/indexeddb-worker.ts",
+        "scripts/**",
+        "spec/**",
+        "release.sh",
+        // For now, we include all source files as entrypoints as we have been bad about gutwrenched imports
+        "src/**",
+    ],
+    project: ["**/*.{js,ts}"],
+    ignore: ["examples/**"],
+    ignoreDependencies: [
+        // Required for `action-validator`
+        "@action-validator/*",
+        // Used for git pre-commit hooks
+        "husky",
+        // Used in script which only runs in environment with `@octokit/rest` installed
+        "@octokit/rest",
+        // Used by jest
+        "jest-environment-jsdom",
+        "babel-jest",
+        "ts-node",
+        // Used by `@babel/plugin-transform-runtime`
+        "@babel/runtime",
+    ],
+    ignoreBinaries: [
+        // Used when available by reusable workflow `.github/workflows/release-make.yml`
+        "dist",
+    ],
+    ignoreExportsUsedInFile: true,
+} satisfies KnipConfig;

package.json

@@ -1,117 +1,135 @@
 {
-  "name": "matrix-js-sdk",
-  "version": "13.0.0",
-  "description": "Matrix Client-Server SDK for Javascript",
-  "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 7 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",
-    "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.3.tgz",
-    "@types/bs58": "^4.0.1",
-    "@types/jest": "^26.0.20",
-    "@types/node": "12",
-    "@types/request": "^2.48.5",
-    "@typescript-eslint/eslint-plugin": "^4.17.0",
-    "@typescript-eslint/parser": "^4.17.0",
-    "allchange": "^1.0.2",
-    "babel-jest": "^26.6.3",
-    "babelify": "^10.0.0",
-    "better-docs": "^2.4.0-beta.9",
-    "browserify": "^17.0.0",
-    "docdash": "^1.2.0",
-    "eslint": "7.18.0",
-    "eslint-config-google": "^0.14.0",
-    "eslint-plugin-matrix-org": "github:matrix-org/eslint-plugin-matrix-org#2306b3d4da4eba908b256014b979f1d3d43d2945",
-    "exorcist": "^1.0.1",
-    "fake-indexeddb": "^3.1.2",
-    "jest": "^26.6.3",
-    "jest-localstorage-mock": "^2.4.6",
-    "jsdoc": "^3.6.6",
-    "matrix-mock-request": "^1.2.3",
-    "rimraf": "^3.0.2",
-    "terser": "^5.5.1",
-    "tsify": "^5.0.2",
-    "typescript": "^4.1.3"
-  },
-  "jest": {
-    "testEnvironment": "node",
-    "testMatch": [
-      "<rootDir>/spec/**/*.spec.{js,ts}"
+    "name": "matrix-js-sdk",
+    "version": "34.1.0",
+    "description": "Matrix Client-Server SDK for Javascript",
+    "engines": {
+        "node": ">=20.0.0"
+    },
+    "scripts": {
+        "prepack": "yarn build",
+        "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
+        "clean": "rimraf lib",
+        "build": "yarn build:dev",
+        "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",
+        "gendoc": "typedoc",
+        "lint": "yarn lint:types && yarn lint:js && yarn lint:workflows",
+        "lint:js": "eslint --max-warnings 0 src spec && prettier --check .",
+        "lint:js-fix": "prettier --log-level=warn --write . && eslint --fix src spec",
+        "lint:types": "tsc --noEmit",
+        "lint:workflows": "find .github/workflows -type f \\( -iname '*.yaml' -o -iname '*.yml' \\) | xargs -I {} sh -c 'echo \"Linting {}\"; action-validator \"{}\"'",
+        "lint:knip": "knip",
+        "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": "./lib/browser-index.js",
+    "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": [
+        "lib",
+        "src",
+        "git-revision.txt",
+        "CHANGELOG.md",
+        "CONTRIBUTING.rst",
+        "LICENSE",
+        "README.md",
+        "package.json",
+        "release.sh"
     ],
-    "coverageReporters": [
-      "text"
-    ]
-  },
-  "typings": "./lib/index.d.ts"
+    "dependencies": {
+        "@babel/runtime": "^7.12.5",
+        "@matrix-org/matrix-sdk-crypto-wasm": "^6.0.0",
+        "@matrix-org/olm": "3.2.15",
+        "another-json": "^0.2.0",
+        "bs58": "^6.0.0",
+        "content-type": "^1.0.4",
+        "jwt-decode": "^4.0.0",
+        "loglevel": "^1.7.1",
+        "matrix-events-sdk": "0.0.1",
+        "matrix-widget-api": "^1.6.0",
+        "oidc-client-ts": "^3.0.1",
+        "p-retry": "4",
+        "sdp-transform": "^2.14.1",
+        "unhomoglyph": "^1.0.6",
+        "uuid": "10"
+    },
+    "devDependencies": {
+        "@action-validator/cli": "^0.6.0",
+        "@action-validator/core": "^0.6.0",
+        "@babel/cli": "^7.12.10",
+        "@babel/core": "^7.12.10",
+        "@babel/eslint-parser": "^7.12.10",
+        "@babel/eslint-plugin": "^7.12.10",
+        "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+        "@babel/plugin-transform-class-properties": "^7.12.1",
+        "@babel/plugin-transform-numeric-separator": "^7.12.7",
+        "@babel/plugin-transform-object-rest-spread": "^7.12.1",
+        "@babel/plugin-transform-runtime": "^7.12.10",
+        "@babel/preset-env": "^7.12.11",
+        "@babel/preset-typescript": "^7.12.7",
+        "@casualbot/jest-sonar-reporter": "2.2.7",
+        "@peculiar/webcrypto": "^1.4.5",
+        "@types/bs58": "^4.0.1",
+        "@types/content-type": "^1.1.5",
+        "@types/debug": "^4.1.7",
+        "@types/jest": "^29.0.0",
+        "@types/node": "18",
+        "@types/sdp-transform": "^2.4.5",
+        "@types/uuid": "10",
+        "@typescript-eslint/eslint-plugin": "^7.0.0",
+        "@typescript-eslint/parser": "^7.0.0",
+        "babel-jest": "^29.0.0",
+        "debug": "^4.3.4",
+        "eslint": "8.57.0",
+        "eslint-config-google": "^0.14.0",
+        "eslint-config-prettier": "^9.0.0",
+        "eslint-import-resolver-typescript": "^3.5.1",
+        "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-jest": "^28.0.0",
+        "eslint-plugin-jsdoc": "^48.0.0",
+        "eslint-plugin-matrix-org": "^1.0.0",
+        "eslint-plugin-tsdoc": "^0.3.0",
+        "eslint-plugin-unicorn": "^54.0.0",
+        "fake-indexeddb": "^5.0.2",
+        "fetch-mock": "10.0.7",
+        "fetch-mock-jest": "^1.5.1",
+        "husky": "^9.0.0",
+        "jest": "^29.0.0",
+        "jest-environment-jsdom": "^29.0.0",
+        "jest-localstorage-mock": "^2.4.6",
+        "jest-mock": "^29.0.0",
+        "knip": "^5.0.0",
+        "lint-staged": "^15.0.2",
+        "matrix-mock-request": "^2.5.0",
+        "node-fetch": "^2.7.0",
+        "prettier": "3.3.2",
+        "rimraf": "^5.0.0",
+        "ts-node": "^10.9.2",
+        "typedoc": "^0.26.0",
+        "typedoc-plugin-coverage": "^3.0.0",
+        "typedoc-plugin-mdn-links": "^3.0.3",
+        "typedoc-plugin-missing-exports": "^3.0.0",
+        "typescript": "^5.3.3"
+    },
+    "@casualbot/jest-sonar-reporter": {
+        "outputDirectory": "coverage",
+        "outputName": "jest-sonar-report.xml",
+        "relativePaths": true
+    },
+    "typings": "./lib/index.d.ts"
 }

release.sh

@@ -1,385 +0,0 @@
-#!/bin/bash
-#
-# 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.
-
-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
-    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
-        echo "hub version 2.5 is required, you have $HUB_VERSION_MAJOR.$HUB_VERSION_MINOR installed"
-        exit
-    fi
-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 [-xz] [-c changelog_file] vX.Y.Z"
-
-help() {
-    cat <<EOF
-$USAGE
-
-    -c changelog_file:  specify name of file containing changelog
-    -x:                 skip updating the changelog
-    -z:                 skip generating the jsdoc
-    -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
-fi
-
-if ! git diff-files --quiet; then
-    echo "this git checkout has uncommitted changes. Refusing to release."
-    exit
-fi
-
-skip_changelog=
-skip_jsdoc=
-skip_npm=
-changelog_file="CHANGELOG.md"
-expected_npm_user="matrixdotorg"
-while getopts hc:u:xzn f; do
-    case $f in
-        h)
-            help
-            exit 0
-            ;;
-        c)
-            changelog_file="$OPTARG"
-            ;;
-        x)
-            skip_changelog=1
-            ;;
-        z)
-            skip_jsdoc=1
-            ;;
-        n)
-            skip_npm=1
-            ;;
-        u)
-            expected_npm_user="$OPTARG"
-            ;;
-    esac
-done
-shift `expr $OPTIND - 1`
-
-if [ $# -ne 1 ]; then
-    echo "Usage: $USAGE" >&2
-    exit 1
-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
-# global cache here to ensure we get the right thing.
-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
-# see if the version has a hyphen in it. Crude,
-# but semver doesn't support postreleases so anything
-# with a hyphen is a prerelease.
-echo $release | grep -q '-' && prerelease=1
-
-if [ $prerelease -eq 1 ]; then
-    echo Making a PRE-RELEASE
-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
-
-if [ -z "$skip_changelog" ]; then
-    echo "Generating changelog"
-    yarn run allchange "$release"
-    read -p "Edit $changelog_file manually, or press enter to continue " REPLY
-
-    if [ -n "$(git ls-files --modified $changelog_file)" ]; then
-        echo "Committing updated changelog"
-        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}"
-
-set -x
-
-# Bump package.json and build the dist
-echo "yarn version"
-# yarn version will automatically commit its modification
-# and make a release tag. We don't want it to create the tag
-# because it can only sign with the default key, but we can
-# only turn off both of these behaviours, so we have to
-# manually commit the result.
-yarn version --no-git-tag-version --new-version "$release"
-
-# For the published and dist versions of the package, we copy the
-# `matrix_lib_main` and `matrix_lib_typings` fields to `main` and `typings` (if
-# they exist). This small bit of gymnastics allows us to use the TypeScript
-# source directly for development without needing to build before linting or
-# testing.
-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
-    fi
-done
-
-# commit yarn.lock if it exists, is versioned, and is modified
-if [[ -f yarn.lock && `git status --porcelain yarn.lock | grep '^ M'` ]];
-then
-    pkglock='yarn.lock'
-else
-    pkglock=''
-fi
-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`
-    if [ "$?" -eq 0 ]; then
-        signing_id=$result
-    fi
-fi
-
-
-# If there is a 'dist' script in the package.json,
-# run it in a separate checkout of the project, then
-# upload any files in the 'dist' directory as release
-# assets.
-# We make a completely separate checkout to be sure
-# we're using released versions of the dependencies
-# (rather than whatever we're pulling in from yarn link)
-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'`
-    echo "Building distribution copy in $builddir"
-    pushd "$builddir"
-    git clone "$projdir" .
-    git checkout "$rel_branch"
-    yarn install --pure-lockfile
-    # We haven't tagged yet, so tell the dist script what version
-    # it's building
-    DIST_VERSION="$tag" yarn dist
-
-    popd
-
-    for i in "$builddir"/dist/*; do
-        assets="$assets -a $i"
-        if [ -n "$signing_id" ]
-        then
-            gpg -u "$signing_id" --armor --output "$i".asc --detach-sig "$i"
-            assets="$assets -a $i.asc"
-        fi
-    done
-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"
-else
-    git tag -a -F "${latest_changes}" "$tag"
-fi
-
-# push the tag and the release branch
-git push origin "$rel_branch" "$tag"
-
-if [ -n "$signing_id" ]; then
-    # make a signature for the source tarball.
-    #
-    # github will make us a tarball from the tag - we want to create a
-    # signature for it, which means that first of all we need to check that
-    # it's correct.
-    #
-    # we can't deterministically build exactly the same tarball, due to
-    # differences in gzip implementation - but we *can* build the same tar - so
-    # the easiest way to check the validity of the tarball from git is to unzip
-    # it and compare it with our own idea of what the tar should look like.
-
-    # the name of the sig file we want to create
-    source_sigfile="${tag}-src.tar.gz.asc"
-
-    tarfile="$tag.tar.gz"
-    gh_project_url=$(git remote get-url origin |
-                            sed -e 's#^git@github\.com:#https://github.com/#' \
-                                -e 's#^git\+ssh://git@github\.com/#https://github.com/#' \
-                                -e 's/\.git$//')
-    project_name="${gh_project_url##*/}"
-    curl -L "${gh_project_url}/archive/${tarfile}" -o "${tarfile}"
-
-    # unzip it and compare it with the tar we would generate
-    if ! cmp --silent <(gunzip -c $tarfile) \
-         <(git archive --format tar --prefix="${project_name}-${release}/" "$tag"); then
-
-        # we don't bail out here, because really it's more likely that our comparison
-        # screwed up and it's super annoying to abort the script at this point.
-        cat >&2 <<EOF
-!!!!!!!!!!!!!!!!!
-!!!! WARNING !!!!
-
-Mismatch between our own tarfile and that generated by github: not signing
-source tarball.
-
-To resolve, determine if $tarfile is correct, and if so sign it with gpg and
-attach it to the release as $source_sigfile.
-
-!!!!!!!!!!!!!!!!!
-EOF
-    else
-        gpg -u "$signing_id" --armor --output "$source_sigfile" --detach-sig "$tarfile"
-        assets="$assets -a $source_sigfile"
-    fi
-fi
-
-hubflags=''
-if [ $prerelease -eq 1 ]; then
-    hubflags='-p'
-fi
-
-release_text=`mktemp`
-echo "$tag" > "${release_text}"
-echo >> "${release_text}"
-cat "${latest_changes}" >> "${release_text}"
-hub release create $hubflags $assets -F "${release_text}" "$tag"
-
-if [ $dodist -eq 0 ]; then
-    rm -rf "$builddir"
-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 [ -z "$skip_jsdoc" ]; then
-    echo "generating jsdocs"
-    yarn gendoc
-
-    echo "copying jsdocs to gh-pages branch"
-    git checkout gh-pages
-    git pull
-    cp -a ".jsdoc/matrix-js-sdk/$release" .
-    perl -i -pe 'BEGIN {$rel=shift} $_ =~ /^<\/ul>/ && print
-        "<li><a href=\"${rel}/index.html\">Version ${rel}</a></li>\n"' \
-        $release index.html
-    git add "$release"
-    git commit --no-verify -m "Add jsdoc for $release" index.html "$release"
-    git push origin gh-pages
-fi
-
-# if it is a pre-release, leave it on the release branch for now.
-if [ $prerelease -eq 1 ]; then
-    git checkout "$rel_branch"
-    exit 0
-fi
-
-# merge release branch to master
-echo "updating master branch"
-git checkout master
-git pull
-git merge "$rel_branch" --no-edit
-
-# push master to github
-git push origin master
-
-# finally, merge master back onto develop (if it exists)
-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

scripts/changelog_head.py

@@ -15,4 +15,4 @@ for line in sys.stdin:
             break
         found_first_header = True
     elif not re.match(r"^=+$", line) and len(line) > 0:
-        print line
+        print(line)

scripts/release/merge-release-notes.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+
+async function listReleases(github, owner, repo) {
+    const response = await github.rest.repos.listReleases({
+        owner,
+        repo,
+        per_page: 100,
+    });
+    // Filters out draft releases
+    return response.data.filter((release) => !release.draft);
+}
+
+// Dependency can be a tuple of dependency, from version, to version, in which case a list of releases in that range (to inclusive) will be returned
+// Or it can be a string in the form accepted by `getRelease`
+async function getReleases(github, dependency) {
+    if (Array.isArray(dependency)) {
+        const [dep, fromVersion, toVersion] = dependency;
+        const upstreamPackageJson = getDependencyPackageJson(dep);
+        const [owner, repo] = upstreamPackageJson.repository.url.split("/").slice(-2);
+
+        const unfilteredReleases = await listReleases(github, owner, repo);
+        // Only include non-draft & non-prerelease releases, unless the to-release is a pre-release, include that one
+        const releases = unfilteredReleases.filter(
+            (release) => !release.prerelease || release.tag_name === `v${toVersion}`,
+        );
+
+        const fromVersionIndex = releases.findIndex((release) => release.tag_name === `v${fromVersion}`);
+        const toVersionIndex = releases.findIndex((release) => release.tag_name === `v${toVersion}`);
+
+        return releases.slice(toVersionIndex, fromVersionIndex);
+    }
+
+    return [await getRelease(github, dependency)];
+}
+
+// Dependency can be the name of an entry in package.json, in which case the owner, repo & version will be looked up in its own package.json
+// Or it can be a string in the form owner/repo@tag - in this case the tag is used exactly to find the release
+// Or it can be a string in the form owner/repo~tag - in this case the latest tag in the same major.minor.patch set is used to find the release
+async function getRelease(github, dependency) {
+    let owner;
+    let repo;
+    let tag;
+
+    if (dependency.includes("/")) {
+        let rest;
+        [owner, rest] = dependency.split("/");
+
+        if (dependency.includes("@")) {
+            [repo, tag] = rest.split("@");
+        } else if (dependency.includes("~")) {
+            [repo, tag] = rest.split("~");
+
+            if (tag.includes("-rc.")) {
+                // If the tag is an RC, find the latest matching RC in the set
+                try {
+                    const releases = await listReleases(github, owner, repo);
+                    const baseVersion = tag.split("-rc.")[0];
+                    const release = releases.find((release) => release.tag_name.startsWith(baseVersion));
+                    if (release) return release;
+                } catch (e) {
+                    // Fall back to getReleaseByTag
+                }
+            }
+        }
+    } else {
+        const upstreamPackageJson = getDependencyPackageJson(dependency);
+        [owner, repo] = upstreamPackageJson.repository.url.split("/").slice(-2);
+        tag = `v${upstreamPackageJson.version}`;
+    }
+
+    const response = await github.rest.repos.getReleaseByTag({
+        owner,
+        repo,
+        tag,
+    });
+    return response.data;
+}
+
+function getDependencyPackageJson(dependency) {
+    return JSON.parse(fs.readFileSync(`./node_modules/${dependency}/package.json`, "utf8"));
+}
+
+const HEADING_PREFIX = "## ";
+
+const categories = [
+    "🔒 SECURITY FIXES",
+    "🚨 BREAKING CHANGESd",
+    "🦖 Deprecations",
+    "✨ Features",
+    "🐛 Bug Fixes",
+    "🧰 Maintenance",
+];
+
+const parseReleaseNotes = (body, sections) => {
+    let heading = null;
+    for (const line of body.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith(HEADING_PREFIX)) {
+            heading = trimmed.slice(HEADING_PREFIX.length);
+            if (!categories.includes(heading)) heading = null;
+            continue;
+        }
+        if (heading && trimmed) {
+            sections[heading].push(trimmed);
+        }
+    }
+};
+
+const main = async ({ github, releaseId, dependencies }) => {
+    const { GITHUB_REPOSITORY } = process.env;
+    const [owner, repo] = GITHUB_REPOSITORY.split("/");
+
+    const { data: release } = await github.rest.repos.getRelease({
+        owner,
+        repo,
+        release_id: releaseId,
+    });
+
+    const sections = Object.fromEntries(categories.map((cat) => [cat, []]));
+    parseReleaseNotes(release.body, sections);
+    for (const dependency of dependencies) {
+        const releases = await getReleases(github, dependency);
+        for (const release of releases) {
+            parseReleaseNotes(release.body, sections);
+        }
+    }
+
+    const intro = release.body.split(HEADING_PREFIX, 2)[0].trim();
+
+    let output = "";
+    if (intro) {
+        output = intro + "\n\n";
+    }
+
+    for (const section in sections) {
+        const lines = sections[section];
+        if (!lines.length) continue;
+        output += HEADING_PREFIX + section + "\n\n";
+        output += lines.join("\n");
+        output += "\n\n";
+    }
+
+    return output;
+};
+
+// This is just for testing locally
+// Needs environment variables GITHUB_TOKEN & GITHUB_REPOSITORY
+if (require.main === module) {
+    const { Octokit } = require("@octokit/rest");
+    const github = new Octokit({ auth: process.env.GITHUB_TOKEN });
+    if (process.argv.length < 4) {
+        // eslint-disable-next-line no-console
+        console.error("Usage: node merge-release-notes.js owner/repo:release_id npm-package-name ...");
+        process.exit(1);
+    }
+    const [releaseId, ...dependencies] = process.argv.slice(2);
+    main({ github, releaseId, dependencies }).then((output) => {
+        // eslint-disable-next-line no-console
+        console.log(output);
+    });
+}
+
+module.exports = main;

scripts/release/post-merge-master.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# When merging to develop, we need revert the `main` and `typings` fields if we adjusted them previously.
+for i in main typings browser
+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

scripts/release/pre-release.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# For the published and dist versions of the package,
+# we copy the `matrix_lib_main` and `matrix_lib_typings` fields to `main` and `typings` (if they exist).
+# This small bit of gymnastics allows us to use the TypeScript source directly for development without
+# needing to build before linting or testing.
+
+for i in main typings browser
+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 && yarn prettier --write package.json
+    fi
+done

scripts/switch_package_to_release.js

@@ -0,0 +1,22 @@
+#!/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];
+        }
+    }
+
+    // matrix-js-sdk is built into ECMAScript modules. Make sure we declare it as such.
+    // See https://nodejs.org/api/packages.html#type.
+    pkgJson["type"] = "module";
+
+    await fsProm.writeFile(PKGJSON, JSON.stringify(pkgJson, null, 2));
+}
+
+main();

sonar-project.properties

@@ -0,0 +1,16 @@
+sonar.projectKey=matrix-js-sdk
+sonar.organization=matrix-org
+
+# Encoding of the source code. Default is default system encoding
+#sonar.sourceEncoding=UTF-8
+
+sonar.sources=src
+sonar.tests=spec
+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/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.js

@@ -1,236 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-Copyright 2017 Vector Creations Ltd
-Copyright 2018-2019 New Vector Ltd
-
-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 olm before the sdk if possible
-import './olm-loader';
-
-import MockHttpBackend from 'matrix-mock-request';
-import { LocalStorageCryptoStore } from '../src/crypto/store/localStorage-crypto-store';
-import { logger } from '../src/logger';
-import { WebStorageSessionStore } from "../src/store/session/webstorage";
-import { syncPromise } from "./test-utils";
-import { createClient } from "../src/matrix";
-import { MockStorageApi } from "./MockStorageApi";
-
-/**
- * Wrapper for a MockStorageApi, MockHttpBackend and MatrixClient
- *
- * @constructor
- * @param {string} userId
- * @param {string} deviceId
- * @param {string} accessToken
- *
- * @param {WebStorage=} sessionStoreBackend a web storage object to use for the
- *     session store. If undefined, we will create a MockStorageApi.
- * @param {object} options additional options to pass to the client
- */
-export function TestClient(
-    userId, deviceId, accessToken, sessionStoreBackend, options,
-) {
-    this.userId = userId;
-    this.deviceId = deviceId;
-
-    if (sessionStoreBackend === undefined) {
-        sessionStoreBackend = new MockStorageApi();
-    }
-    const sessionStore = new WebStorageSessionStore(sessionStoreBackend);
-
-    this.httpBackend = new MockHttpBackend();
-
-    options = Object.assign({
-        baseUrl: "http://" + userId + ".test.server",
-        userId: userId,
-        accessToken: accessToken,
-        deviceId: deviceId,
-        sessionStore: sessionStore,
-        request: this.httpBackend.requestFn,
-    }, options);
-    if (!options.cryptoStore) {
-        // expose this so the tests can get to it
-        this.cryptoStore = new LocalStorageCryptoStore(sessionStoreBackend);
-        options.cryptoStore = this.cryptoStore;
-    }
-    this.client = createClient(options);
-
-    this.deviceKeys = null;
-    this.oneTimeKeys = {};
-    this.callEventHandler = {
-        calls: new Map(),
-    };
-}
-
-TestClient.prototype.toString = function() {
-    return 'TestClient[' + this.userId + ']';
-};
-
-/**
- * start the client, and wait for it to initialise.
- *
- * @return {Promise}
- */
-TestClient.prototype.start = function() {
-    logger.log(this + ': starting');
-    this.httpBackend.when("GET", "/pushrules").respond(200, {});
-    this.httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
-    this.expectDeviceKeyUpload();
-
-    // we let the client do a very basic initial sync, which it needs before
-    // it will upload one-time keys.
-    this.httpBackend.when("GET", "/sync").respond(200, { next_batch: 1 });
-
-    this.client.startClient({
-        // set this so that we can get hold of failed events
-        pendingEventOrdering: 'detached',
-    });
-
-    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
- */
-TestClient.prototype.stop = function() {
-    this.client.stopClient();
-    return this.httpBackend.stop();
-};
-
-/**
- * Set up expectations that the client will upload device keys.
- */
-TestClient.prototype.expectDeviceKeyUpload = function() {
-    const self = this;
-    this.httpBackend.when("POST", "/keys/upload").respond(200, function(path, content) {
-        expect(content.one_time_keys).toBe(undefined);
-        expect(content.device_keys).toBeTruthy();
-
-        logger.log(self + ': received device keys');
-        // we expect this to happen before any one-time keys are uploaded.
-        expect(Object.keys(self.oneTimeKeys).length).toEqual(0);
-
-        self.deviceKeys = content.device_keys;
-        return { one_time_key_counts: { signed_curve25519: 0 } };
-    });
-};
-
-/**
- * If one-time keys have already been uploaded, return them. Otherwise,
- * set up an expectation that the keys will be uploaded, and wait for
- * that to happen.
- *
- * @returns {Promise} for the one-time keys
- */
-TestClient.prototype.awaitOneTimeKeyUpload = function() {
-    if (Object.keys(this.oneTimeKeys).length != 0) {
-        // already got one-time keys
-        return Promise.resolve(this.oneTimeKeys);
-    }
-
-    this.httpBackend.when("POST", "/keys/upload")
-        .respond(200, (path, content) => {
-            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,
-            } };
-        });
-
-    this.httpBackend.when("POST", "/keys/upload")
-          .respond(200, (path, content) => {
-              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);
-              this.oneTimeKeys = content.one_time_keys;
-              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) => {
-        expect(flushed).toEqual(2);
-        return this.oneTimeKeys;
-    });
-};
-
-/**
- * Set up expectations that the client will query device keys.
- *
- * We check that the query contains each of the users in `response`.
- *
- * @param {Object} response   response to the query.
- */
-TestClient.prototype.expectKeyQuery = function(response) {
-    this.httpBackend.when('POST', '/keys/query').respond(
-        200, (path, content) => {
-            Object.keys(response.device_keys).forEach((userId) => {
-                expect(content.device_keys[userId]).toEqual(
-                    [],
-                    "Expected key query for " + userId + ", got " +
-                    Object.keys(content.device_keys),
-                );
-            });
-            return response;
-        });
-};
-
-/**
- * get the uploaded curve25519 device key
- *
- * @return {string} base64 device key
- */
-TestClient.prototype.getDeviceKey = function() {
-    const keyId = 'curve25519:' + this.deviceId;
-    return this.deviceKeys.keys[keyId];
-};
-
-/**
- * get the uploaded ed25519 device key
- *
- * @return {string} base64 device key
- */
-TestClient.prototype.getSigningKey = function() {
-    const keyId = 'ed25519:' + this.deviceId;
-    return this.deviceKeys.keys[keyId];
-};
-
-/**
- * flush a single /sync request, and wait for the syncing event
- *
- * @returns {Promise} promise which completes once the sync has been flushed
- */
-TestClient.prototype.flushSync = function() {
-    logger.log(`${this}: flushSync`);
-    return Promise.all([
-        this.httpBackend.flush('/sync', 1),
-        syncPromise(this.client),
-    ]).then(() => {
-        logger.log(`${this}: flushSync completed`);
-    });
-};
-
-TestClient.prototype.isFallbackICEServerAllowed = function() {
-    return true;
-};

spec/TestClient.ts

@@ -0,0 +1,266 @@
+/*
+Copyright 2016 OpenMarket Ltd
+Copyright 2017 Vector Creations Ltd
+Copyright 2018-2019 New Vector Ltd
+
+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.
+*/
+
+// `expect` is allowed in helper functions which are called within `test`/`it` blocks
+/* eslint-disable jest/no-standalone-expect */
+
+// load olm before the sdk if possible
+import "./olm-loader";
+
+import MockHttpBackend from "matrix-mock-request";
+
+import type { IDeviceKeys, IOneTimeKey } from "../src/@types/crypto";
+import type { IE2EKeyReceiver } from "./test-utils/E2EKeyReceiver";
+import { LocalStorageCryptoStore } from "../src/crypto/store/localStorage-crypto-store";
+import { logger } from "../src/logger";
+import { syncPromise } from "./test-utils/test-utils";
+import { createClient, IStartClientOpts } from "../src/matrix";
+import { ICreateClientOpts, IDownloadKeyResult, MatrixClient, PendingEventOrdering } from "../src/client";
+import { MockStorageApi } from "./MockStorageApi";
+import { IKeysUploadResponse, IUploadKeysRequest } from "../src/client";
+import { ISyncResponder } from "./test-utils/SyncResponder";
+
+/**
+ * Wrapper for a MockStorageApi, MockHttpBackend and MatrixClient
+ *
+ * @deprecated Avoid using this; it is tied too tightly to matrix-mock-request and is generally inconvenient to use.
+ *    Instead, construct a MatrixClient manually, use fetch-mock-jest to intercept the HTTP requests, and
+ *    use things like {@link E2EKeyReceiver} and {@link SyncResponder} to manage the requests.
+ */
+export class TestClient implements IE2EKeyReceiver, ISyncResponder {
+    public readonly httpBackend: MockHttpBackend;
+    public readonly client: MatrixClient;
+    public deviceKeys?: IDeviceKeys | null;
+    public oneTimeKeys?: Record<string, IOneTimeKey>;
+
+    constructor(
+        public readonly userId?: string,
+        public readonly deviceId?: string,
+        accessToken?: string,
+        sessionStoreBackend?: Storage,
+        options?: Partial<ICreateClientOpts>,
+    ) {
+        if (sessionStoreBackend === undefined) {
+            sessionStoreBackend = new MockStorageApi() as unknown as Storage;
+        }
+
+        this.httpBackend = new MockHttpBackend();
+
+        const fullOptions: ICreateClientOpts = {
+            baseUrl: "http://" + userId?.slice(1).replace(":", ".") + ".test.server",
+            userId: userId,
+            accessToken: accessToken,
+            deviceId: deviceId,
+            fetchFn: this.httpBackend.fetchFn as typeof global.fetch,
+            ...options,
+        };
+        if (!fullOptions.cryptoStore) {
+            // expose this so the tests can get to it
+            fullOptions.cryptoStore = new LocalStorageCryptoStore(sessionStoreBackend);
+        }
+        this.client = createClient(fullOptions);
+
+        this.deviceKeys = null;
+        this.oneTimeKeys = {};
+    }
+
+    public toString(): string {
+        return "TestClient[" + this.userId + "]";
+    }
+
+    /**
+     * start the client, and wait for it to initialise.
+     */
+    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: ["v1.1"],
+        });
+        this.httpBackend.when("GET", "/pushrules").respond(200, {});
+        this.httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
+        this.expectDeviceKeyUpload();
+
+        // we let the client do a very basic initial sync, which it needs before
+        // it will upload one-time keys.
+        this.httpBackend.when("GET", "/sync").respond(200, { next_batch: 1 });
+
+        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");
+        });
+    }
+
+    /**
+     * stop the client
+     * @returns Promise which resolves once the mock http backend has finished all pending flushes
+     */
+    public async stop(): Promise<void> {
+        this.client.stopClient();
+        await this.httpBackend.stop();
+    }
+
+    /**
+     * Set up expectations that the client will upload device keys (and possibly one-time keys)
+     */
+    public expectDeviceKeyUpload() {
+        this.httpBackend
+            .when("POST", "/keys/upload")
+            .respond<IKeysUploadResponse, IUploadKeysRequest>(200, (_path, content) => {
+                expect(content.device_keys).toBeTruthy();
+
+                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);
+
+                this.deviceKeys = content.device_keys;
+
+                // 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,
+                    },
+                };
+            });
+    }
+
+    /**
+     * If one-time keys have already been uploaded, return them. Otherwise,
+     * set up an expectation that the keys will be uploaded, and wait for
+     * that to happen.
+     *
+     * @returns Promise for the one-time keys
+     */
+    public awaitOneTimeKeyUpload(): Promise<Record<string, IOneTimeKey>> {
+        if (Object.keys(this.oneTimeKeys!).length != 0) {
+            // already got one-time keys
+            return Promise.resolve(this.oneTimeKeys!);
+        }
+
+        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,
+                    },
+                };
+            });
+
+        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);
+                this.oneTimeKeys = content.one_time_keys;
+                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) => {
+            expect(flushed).toEqual(2);
+            return this.oneTimeKeys!;
+        });
+    }
+
+    /**
+     * Set up expectations that the client will query device keys.
+     *
+     * We check that the query contains each of the users in `response`.
+     *
+     * @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! as Record<string, any>)[userId]).toEqual([]);
+            });
+            return response;
+        });
+    }
+
+    /**
+     * get the uploaded curve25519 device key
+     *
+     * @returns base64 device key
+     */
+    public getDeviceKey(): string {
+        const keyId = "curve25519:" + this.deviceId;
+        return this.deviceKeys!.keys[keyId];
+    }
+
+    /**
+     * get the uploaded ed25519 device key
+     *
+     * @returns base64 device key
+     */
+    public getSigningKey(): string {
+        const keyId = "ed25519:" + this.deviceId;
+        return this.deviceKeys!.keys[keyId];
+    }
+
+    /** Next time we see a sync request (or immediately, if there is one waiting), send the given response
+     *
+     * Calling this will register a response for `/sync`, and then, in the background, flush a single `/sync` request.
+     * Try calling {@link syncPromise} to wait for the sync to complete.
+     *
+     * @param response - response to /sync request
+     */
+    public sendOrQueueSyncResponse(syncResponse: object): void {
+        this.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+        this.httpBackend.flush("/sync", 1);
+    }
+
+    /**
+     * flush a single /sync request, and wait for the syncing event
+     *
+     * @deprecated: prefer to use {@link #sendOrQueueSyncResponse} followed by {@link syncPromise}.
+     */
+    public flushSync(): Promise<void> {
+        logger.log(`${this}: flushSync`);
+        return Promise.all([this.httpBackend.flush("/sync", 1), syncPromise(this.client)]).then(() => {
+            logger.log(`${this}: flushSync completed`);
+        });
+    }
+
+    public isFallbackICEServerAllowed(): boolean {
+        return true;
+    }
+
+    public getUserId(): string {
+        return this.userId!;
+    }
+}

spec/browserify/sync-browserify.spec.js

@@ -1,103 +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 { MockStorageApi } from "../MockStorageApi";
-import { WebStorageSessionStore } from "../../src/store/session/webstorage";
-import MockHttpBackend from "matrix-mock-request";
-import { LocalStorageCryptoStore } from "../../src/crypto/store/localStorage-crypto-store";
-import * as utils from "../test-utils";
-
-const USER_ID = "@user:test.server";
-const DEVICE_ID = "device_id";
-const ACCESS_TOKEN = "access_token";
-const ROOM_ID = "!room_id:server.test";
-
-/* global matrixcs */
-
-describe("Browserify Test", function() {
-    let client;
-    let httpBackend;
-
-    async function createTestClient() {
-        const sessionStoreBackend = new MockStorageApi();
-        const sessionStore = new WebStorageSessionStore(sessionStoreBackend);
-        const httpBackend = new MockHttpBackend();
-
-        const options = {
-            baseUrl: "http://" + USER_ID + ".test.server",
-            userId: USER_ID,
-            accessToken: ACCESS_TOKEN,
-            deviceId: DEVICE_ID,
-            sessionStore: sessionStore,
-            request: httpBackend.requestFn,
-            cryptoStore: new LocalStorageCryptoStore(sessionStoreBackend),
-        };
-
-        const client = matrixcs.createClient(options);
-
-        httpBackend.when("GET", "/pushrules").respond(200, {});
-        httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
-
-        return { client, httpBackend };
-    }
-
-    beforeEach(async () => {
-        ({ client, httpBackend } = await createTestClient());
-        await client.startClient();
-    });
-
-    afterEach(async () => {
-        client.stopClient();
-        await httpBackend.stop();
-    });
-
-    it("Sync", async 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);
-        await Promise.race([
-            Promise.all([
-                httpBackend.flushAllExpected(),
-            ]),
-            new Promise((_, reject) => {
-                client.once("sync.unexpectedError", reject);
-            }),
-        ]);
-    }, 20000); // additional timeout as this test can take quite a while
-});

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

@@ -0,0 +1,508 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import fetchMock from "fetch-mock-jest";
+import "fake-indexeddb/auto";
+import { IDBFactory } from "fake-indexeddb";
+
+import { CRYPTO_BACKENDS, InitCrypto, syncPromise } from "../../test-utils/test-utils";
+import { AuthDict, createClient, CryptoEvent, MatrixClient } from "../../../src";
+import { mockInitialApiRequests, mockSetupCrossSigningRequests } from "../../test-utils/mockEndpoints";
+import { encryptAES } from "../../../src/crypto/aes";
+import { CryptoCallbacks, CrossSigningKey } from "../../../src/crypto-api";
+import { SECRET_STORAGE_ALGORITHM_V1_AES } from "../../../src/secret-storage";
+import { ISyncResponder, SyncResponder } from "../../test-utils/SyncResponder";
+import { E2EKeyReceiver } from "../../test-utils/E2EKeyReceiver";
+import {
+    MASTER_CROSS_SIGNING_PRIVATE_KEY_BASE64,
+    SELF_CROSS_SIGNING_PRIVATE_KEY_BASE64,
+    SELF_CROSS_SIGNING_PUBLIC_KEY_BASE64,
+    SIGNED_CROSS_SIGNING_KEYS_DATA,
+    SIGNED_TEST_DEVICE_DATA,
+    USER_CROSS_SIGNING_PRIVATE_KEY_BASE64,
+} from "../../test-utils/test-data";
+import * as testData from "../../test-utils/test-data";
+import { E2EKeyResponder } from "../../test-utils/E2EKeyResponder";
+import { AccountDataAccumulator } from "../../test-utils/AccountDataAccumulator";
+
+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();
+});
+
+const TEST_USER_ID = "@alice:localhost";
+const TEST_DEVICE_ID = "xzcvb";
+
+/**
+ * Integration tests for cross-signing functionality.
+ *
+ * These tests work by intercepting HTTP requests via fetch-mock rather than mocking out bits of the client, so as
+ * to provide the most effective integration tests possible.
+ */
+describe.each(Object.entries(CRYPTO_BACKENDS))("cross-signing (%s)", (backend: string, initCrypto: InitCrypto) => {
+    // newBackendOnly is the opposite to `oldBackendOnly`: it will skip the test if we are running against the legacy
+    // backend. Once we drop support for legacy crypto, it will go away.
+    const newBackendOnly = backend === "rust-sdk" ? test : test.skip;
+
+    let aliceClient: MatrixClient;
+
+    /** an object which intercepts `/sync` requests from {@link #aliceClient} */
+    let syncResponder: ISyncResponder;
+
+    /** an object which intercepts `/keys/query` requests on the test homeserver */
+    let e2eKeyResponder: E2EKeyResponder;
+
+    // Encryption key used to encrypt cross signing keys
+    const encryptionKey = new Uint8Array(32);
+
+    /**
+     * Create the {@link CryptoCallbacks}
+     */
+    function createCryptoCallbacks(): CryptoCallbacks {
+        return {
+            getSecretStorageKey: (keys, name) => {
+                return Promise.resolve<[string, Uint8Array]>(["key_id", encryptionKey]);
+            },
+        };
+    }
+
+    beforeEach(
+        async () => {
+            // anything that we don't have a specific matcher for silently returns a 404
+            fetchMock.catch(404);
+            fetchMock.config.warnOnFallback = false;
+
+            const homeserverUrl = "https://alice-server.com";
+            aliceClient = createClient({
+                baseUrl: homeserverUrl,
+                userId: TEST_USER_ID,
+                accessToken: "akjgkrgjs",
+                deviceId: TEST_DEVICE_ID,
+                cryptoCallbacks: createCryptoCallbacks(),
+            });
+
+            syncResponder = new SyncResponder(homeserverUrl);
+            e2eKeyResponder = new E2EKeyResponder(homeserverUrl);
+            /** an object which intercepts `/keys/upload` requests on the test homeserver */
+            new E2EKeyReceiver(homeserverUrl);
+
+            // Silence warnings from the backup manager
+            fetchMock.getOnce(new URL("/_matrix/client/v3/room_keys/version", homeserverUrl).toString(), {
+                status: 404,
+                body: { errcode: "M_NOT_FOUND" },
+            });
+
+            await initCrypto(aliceClient);
+        },
+        /* it can take a while to initialise the crypto library on the first pass, so bump up the timeout. */
+        10000,
+    );
+
+    afterEach(async () => {
+        await aliceClient.stopClient();
+        fetchMock.mockReset();
+    });
+
+    /**
+     * Create cross-signing keys and publish the keys
+     *
+     * @param authDict - The parameters to as the `auth` dict in the key upload request.
+     * @see https://spec.matrix.org/v1.6/client-server-api/#authentication-types
+     */
+    async function bootstrapCrossSigning(authDict: AuthDict): Promise<void> {
+        await aliceClient.getCrypto()?.bootstrapCrossSigning({
+            authUploadDeviceSigningKeys: (makeRequest) => makeRequest(authDict).then(() => undefined),
+        });
+    }
+
+    describe("bootstrapCrossSigning (before initialsync completes)", () => {
+        it("publishes keys if none were yet published", async () => {
+            mockSetupCrossSigningRequests();
+
+            // provide a UIA callback, so that the cross-signing keys are uploaded
+            const authDict = { type: "test" };
+            await bootstrapCrossSigning(authDict);
+
+            // check the cross-signing keys upload
+            expect(fetchMock.called("upload-keys")).toBeTruthy();
+            const [, keysOpts] = fetchMock.lastCall("upload-keys")!;
+            const keysBody = JSON.parse(keysOpts!.body as string);
+            expect(keysBody.auth).toEqual(authDict); // check uia dict was passed
+            // there should be a key of each type
+            // master key is signed by the device
+            expect(keysBody).toHaveProperty(`master_key.signatures.[${TEST_USER_ID}].[ed25519:${TEST_DEVICE_ID}]`);
+            const masterKeyId = Object.keys(keysBody.master_key.keys)[0];
+            // ssk and usk are signed by the master key
+            expect(keysBody).toHaveProperty(`self_signing_key.signatures.[${TEST_USER_ID}].[${masterKeyId}]`);
+            expect(keysBody).toHaveProperty(`user_signing_key.signatures.[${TEST_USER_ID}].[${masterKeyId}]`);
+            const sskId = Object.keys(keysBody.self_signing_key.keys)[0];
+
+            // check the publish call
+            expect(fetchMock.called("upload-sigs")).toBeTruthy();
+            const [, sigsOpts] = fetchMock.lastCall("upload-sigs")!;
+            const body = JSON.parse(sigsOpts!.body as string);
+            // there should be a signature for our device, by our self-signing key.
+            expect(body).toHaveProperty(
+                `[${TEST_USER_ID}].[${TEST_DEVICE_ID}].signatures.[${TEST_USER_ID}].[${sskId}]`,
+            );
+        });
+
+        newBackendOnly("get cross signing keys from secret storage and import them", async () => {
+            // Return public cross signing keys
+            e2eKeyResponder.addCrossSigningData(SIGNED_CROSS_SIGNING_KEYS_DATA);
+
+            mockInitialApiRequests(aliceClient.getHomeserverUrl());
+
+            // Encrypt the private keys and return them in the /sync response as if they are in Secret Storage
+            const masterKey = await encryptAES(
+                MASTER_CROSS_SIGNING_PRIVATE_KEY_BASE64,
+                encryptionKey,
+                "m.cross_signing.master",
+            );
+            const selfSigningKey = await encryptAES(
+                SELF_CROSS_SIGNING_PRIVATE_KEY_BASE64,
+                encryptionKey,
+                "m.cross_signing.self_signing",
+            );
+            const userSigningKey = await encryptAES(
+                USER_CROSS_SIGNING_PRIVATE_KEY_BASE64,
+                encryptionKey,
+                "m.cross_signing.user_signing",
+            );
+
+            syncResponder.sendOrQueueSyncResponse({
+                next_batch: 1,
+                account_data: {
+                    events: [
+                        {
+                            type: "m.cross_signing.master",
+                            content: {
+                                encrypted: {
+                                    key_id: masterKey,
+                                },
+                            },
+                        },
+                        {
+                            type: "m.cross_signing.self_signing",
+                            content: {
+                                encrypted: {
+                                    key_id: selfSigningKey,
+                                },
+                            },
+                        },
+                        {
+                            type: "m.cross_signing.user_signing",
+                            content: {
+                                encrypted: {
+                                    key_id: userSigningKey,
+                                },
+                            },
+                        },
+                        {
+                            type: "m.secret_storage.key.key_id",
+                            content: {
+                                key: "key_id",
+                                algorithm: SECRET_STORAGE_ALGORITHM_V1_AES,
+                            },
+                        },
+                    ],
+                },
+            });
+            await aliceClient.startClient();
+            await syncPromise(aliceClient);
+
+            // we expect a request to upload signatures for our device ...
+            fetchMock.post({ url: "path:/_matrix/client/v3/keys/signatures/upload", name: "upload-sigs" }, {});
+
+            // we expect the UserTrustStatusChanged event to be fired after the cross signing keys import
+            const userTrustStatusChangedPromise = new Promise<string>((resolve) =>
+                aliceClient.on(CryptoEvent.UserTrustStatusChanged, resolve),
+            );
+
+            const authDict = { type: "test" };
+            await bootstrapCrossSigning(authDict);
+
+            // Check if the UserTrustStatusChanged event was fired
+            expect(await userTrustStatusChangedPromise).toBe(aliceClient.getUserId());
+
+            // Expect the signature to be uploaded
+            expect(fetchMock.called("upload-sigs")).toBeTruthy();
+            const [, sigsOpts] = fetchMock.lastCall("upload-sigs")!;
+            const body = JSON.parse(sigsOpts!.body as string);
+            // the device should have a signature with the public self cross signing keys.
+            expect(body).toHaveProperty(
+                `[${TEST_USER_ID}].[${TEST_DEVICE_ID}].signatures.[${TEST_USER_ID}].[ed25519:${SELF_CROSS_SIGNING_PUBLIC_KEY_BASE64}]`,
+            );
+        });
+
+        it("can bootstrapCrossSigning twice", async () => {
+            mockSetupCrossSigningRequests();
+
+            const authDict = { type: "test" };
+            await bootstrapCrossSigning(authDict);
+
+            // a second call should do nothing except GET requests
+            fetchMock.mockClear();
+            await bootstrapCrossSigning(authDict);
+            const calls = fetchMock.calls((url, opts) => opts.method != "GET");
+            expect(calls.length).toEqual(0);
+        });
+
+        newBackendOnly("will upload existing cross-signing keys to an established secret storage", async () => {
+            // This rather obscure codepath covers the case that:
+            //   - 4S is set up and working
+            //   - our device has private cross-signing keys, but has not published them to 4S
+            //
+            // To arrange that, we call `bootstrapCrossSigning` on our main device, and then (pretend to) set up 4S from
+            // a *different* device. Then, when we call `bootstrapCrossSigning` again, it should do the honours.
+
+            mockSetupCrossSigningRequests();
+            const accountDataAccumulator = new AccountDataAccumulator();
+            accountDataAccumulator.interceptGetAccountData();
+
+            const authDict = { type: "test" };
+            await bootstrapCrossSigning(authDict);
+
+            // Pretend that another device has uploaded a 4S key
+            accountDataAccumulator.accountDataEvents.set("m.secret_storage.default_key", { key: "key_id" });
+            accountDataAccumulator.accountDataEvents.set("m.secret_storage.key.key_id", {
+                key: "keykeykey",
+                algorithm: SECRET_STORAGE_ALGORITHM_V1_AES,
+            });
+
+            // Prepare for the cross-signing keys
+            const p = accountDataAccumulator.interceptSetAccountData(":type(m.cross_signing..*)");
+
+            await bootstrapCrossSigning(authDict);
+            await p;
+
+            // The cross-signing keys should have been uploaded
+            expect(accountDataAccumulator.accountDataEvents.has("m.cross_signing.master")).toBeTruthy();
+            expect(accountDataAccumulator.accountDataEvents.has("m.cross_signing.self_signing")).toBeTruthy();
+            expect(accountDataAccumulator.accountDataEvents.has("m.cross_signing.user_signing")).toBeTruthy();
+        });
+    });
+
+    describe("getCrossSigningStatus()", () => {
+        it("should return correct values without bootstrapping cross-signing", async () => {
+            mockSetupCrossSigningRequests();
+
+            const crossSigningStatus = await aliceClient.getCrypto()!.getCrossSigningStatus();
+
+            // Expect the cross signing keys to be unavailable
+            expect(crossSigningStatus).toStrictEqual({
+                publicKeysOnDevice: false,
+                privateKeysInSecretStorage: false,
+                privateKeysCachedLocally: { masterKey: false, userSigningKey: false, selfSigningKey: false },
+            });
+        });
+
+        it("should return correct values after bootstrapping cross-signing", async () => {
+            mockSetupCrossSigningRequests();
+
+            // provide a UIA callback, so that the cross-signing keys are uploaded
+            const authDict = { type: "test" };
+            await bootstrapCrossSigning(authDict);
+
+            const crossSigningStatus = await aliceClient.getCrypto()!.getCrossSigningStatus();
+
+            // Expect the cross signing keys to be available
+            expect(crossSigningStatus).toStrictEqual({
+                publicKeysOnDevice: true,
+                privateKeysInSecretStorage: false,
+                privateKeysCachedLocally: { masterKey: true, userSigningKey: true, selfSigningKey: true },
+            });
+        });
+    });
+
+    describe("isCrossSigningReady()", () => {
+        it("should return false if cross-signing is not bootstrapped", async () => {
+            mockSetupCrossSigningRequests();
+
+            const isCrossSigningReady = await aliceClient.getCrypto()!.isCrossSigningReady();
+
+            expect(isCrossSigningReady).toBeFalsy();
+        });
+
+        it("should return true after bootstrapping cross-signing", async () => {
+            mockSetupCrossSigningRequests();
+            await bootstrapCrossSigning({ type: "test" });
+
+            const isCrossSigningReady = await aliceClient.getCrypto()!.isCrossSigningReady();
+
+            expect(isCrossSigningReady).toBeTruthy();
+        });
+
+        it("should return false if identity is not trusted, even if the secrets are in 4S", async () => {
+            e2eKeyResponder.addCrossSigningData(SIGNED_CROSS_SIGNING_KEYS_DATA);
+
+            // Complete initial sync, to get the 4S account_data events stored
+            mockInitialApiRequests(aliceClient.getHomeserverUrl());
+
+            // For this test we need to have a well-formed 4S setup.
+            const mockSecretInfo = {
+                encrypted: {
+                    // Don't care about the actual values here, just need to be present for validation
+                    KeyId: {
+                        iv: "IVIVIVIVIVIVIV",
+                        ciphertext: "CIPHERTEXTB64",
+                        mac: "MACMACMAC",
+                    },
+                },
+            };
+            syncResponder.sendOrQueueSyncResponse({
+                next_batch: 1,
+                account_data: {
+                    events: [
+                        {
+                            type: "m.secret_storage.key.KeyId",
+                            content: {
+                                algorithm: "m.secret_storage.v1.aes-hmac-sha2",
+                                // iv and mac not relevant for this test
+                            },
+                        },
+                        {
+                            type: "m.secret_storage.default_key",
+                            content: {
+                                key: "KeyId",
+                            },
+                        },
+                        {
+                            type: "m.cross_signing.master",
+                            content: mockSecretInfo,
+                        },
+                        {
+                            type: "m.cross_signing.user_signing",
+                            content: mockSecretInfo,
+                        },
+                        {
+                            type: "m.cross_signing.self_signing",
+                            content: mockSecretInfo,
+                        },
+                    ],
+                },
+            });
+            await aliceClient.startClient();
+            await syncPromise(aliceClient);
+
+            // Sanity: ensure that the secrets are in 4S
+            const status = await aliceClient.getCrypto()!.getCrossSigningStatus();
+            expect(status.privateKeysInSecretStorage).toBeTruthy();
+
+            const isCrossSigningReady = await aliceClient.getCrypto()!.isCrossSigningReady();
+
+            expect(isCrossSigningReady).toBeFalsy();
+        });
+    });
+
+    describe("getCrossSigningKeyId", () => {
+        /**
+         * Intercept /keys/device_signing/upload request and return the cross signing keys
+         * https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv3keysdevice_signingupload
+         *
+         * @returns the cross signing keys
+         */
+        function awaitCrossSigningKeysUpload() {
+            return new Promise<any>((resolve) => {
+                fetchMock.post(
+                    // legacy crypto uses /unstable/; /v3/ is correct
+                    {
+                        url: new RegExp("/_matrix/client/(unstable|v3)/keys/device_signing/upload"),
+                        name: "upload-keys",
+                    },
+                    (url, options) => {
+                        const content = JSON.parse(options.body as string);
+                        resolve(content);
+                        return {};
+                    },
+                    // Override the routes define in `mockSetupCrossSigningRequests`
+                    { overwriteRoutes: true },
+                );
+            });
+        }
+
+        it("should return the cross signing key id for each cross signing key", async () => {
+            mockSetupCrossSigningRequests();
+
+            // Intercept cross signing keys upload
+            const crossSigningKeysPromise = awaitCrossSigningKeysUpload();
+
+            // provide a UIA callback, so that the cross-signing keys are uploaded
+            const authDict = { type: "test" };
+            await bootstrapCrossSigning(authDict);
+            // Get the cross signing keys
+            const crossSigningKeys = await crossSigningKeysPromise;
+
+            const getPubKey = (crossSigningKey: any) => Object.values(crossSigningKey!.keys)[0];
+
+            const masterKeyId = await aliceClient.getCrypto()!.getCrossSigningKeyId();
+            expect(masterKeyId).toBe(getPubKey(crossSigningKeys.master_key));
+
+            const selfSigningKeyId = await aliceClient.getCrypto()!.getCrossSigningKeyId(CrossSigningKey.SelfSigning);
+            expect(selfSigningKeyId).toBe(getPubKey(crossSigningKeys.self_signing_key));
+
+            const userSigningKeyId = await aliceClient.getCrypto()!.getCrossSigningKeyId(CrossSigningKey.UserSigning);
+            expect(userSigningKeyId).toBe(getPubKey(crossSigningKeys.user_signing_key));
+        });
+    });
+
+    describe("crossSignDevice", () => {
+        beforeEach(async () => {
+            // We want to use fake timers, but the wasm bindings of matrix-sdk-crypto rely on a working `queueMicrotask`.
+            jest.useFakeTimers({ doNotFake: ["queueMicrotask"] });
+
+            // make sure that there is another device which we can sign
+            e2eKeyResponder.addDeviceKeys(SIGNED_TEST_DEVICE_DATA);
+
+            // Complete initialsync, to get the outgoing requests going
+            mockInitialApiRequests(aliceClient.getHomeserverUrl());
+            syncResponder.sendOrQueueSyncResponse({ next_batch: 1 });
+            await aliceClient.startClient();
+            await syncPromise(aliceClient);
+
+            // Wait for legacy crypto to find the device
+            await jest.advanceTimersByTimeAsync(10);
+
+            const devices = await aliceClient.getCrypto()!.getUserDeviceInfo([aliceClient.getSafeUserId()]);
+            expect(devices.get(aliceClient.getSafeUserId())!.has(testData.TEST_DEVICE_ID)).toBeTruthy();
+        });
+
+        afterEach(async () => {
+            jest.useRealTimers();
+        });
+
+        it("fails for an unknown device", async () => {
+            await expect(aliceClient.getCrypto()!.crossSignDevice("unknown")).rejects.toThrow("Unknown device");
+        });
+
+        it("cross-signs the device", async () => {
+            mockSetupCrossSigningRequests();
+            await aliceClient.getCrypto()!.bootstrapCrossSigning({});
+
+            fetchMock.mockClear();
+            await aliceClient.getCrypto()!.crossSignDevice(testData.TEST_DEVICE_ID);
+
+            // check that a sig for the device was uploaded
+            const calls = fetchMock.calls("upload-sigs");
+            expect(calls.length).toEqual(1);
+            const body = JSON.parse(calls[0][1]!.body as string);
+            const deviceSig = body[aliceClient.getSafeUserId()][testData.TEST_DEVICE_ID];
+            expect(deviceSig).toHaveProperty("signatures");
+        });
+    });
+});

spec/integ/crypto/device-dehydration.spec.ts

@@ -0,0 +1,181 @@
+/*
+Copyright 2024 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 fetchMock from "fetch-mock-jest";
+
+import { createClient, ClientEvent, MatrixClient, MatrixEvent } from "../../../src";
+import { RustCrypto } from "../../../src/rust-crypto/rust-crypto";
+import { AddSecretStorageKeyOpts } from "../../../src/secret-storage";
+import { E2EKeyReceiver } from "../../test-utils/E2EKeyReceiver";
+import { E2EKeyResponder } from "../../test-utils/E2EKeyResponder";
+
+describe("Device dehydration", () => {
+    it("should rehydrate and dehydrate a device", async () => {
+        jest.useFakeTimers({ doNotFake: ["queueMicrotask"] });
+
+        const matrixClient = createClient({
+            baseUrl: "http://test.server",
+            userId: "@alice:localhost",
+            deviceId: "aliceDevice",
+            cryptoCallbacks: {
+                getSecretStorageKey: async (keys: any, name: string) => {
+                    return [[...Object.keys(keys.keys)][0], new Uint8Array(32)];
+                },
+            },
+        });
+
+        await initializeSecretStorage(matrixClient, "@alice:localhost", "http://test.server");
+
+        // count the number of times the dehydration key gets set
+        let setDehydrationCount = 0;
+        matrixClient.on(ClientEvent.AccountData, (event: MatrixEvent) => {
+            if (event.getType() === "org.matrix.msc3814") {
+                setDehydrationCount++;
+            }
+        });
+
+        const crypto = matrixClient.getCrypto()!;
+        fetchMock.config.overwriteRoutes = true;
+
+        // start dehydration -- we start with no dehydrated device, and we
+        // store the dehydrated device that we create
+        fetchMock.get("path:/_matrix/client/unstable/org.matrix.msc3814.v1/dehydrated_device", {
+            status: 404,
+            body: {
+                errcode: "M_NOT_FOUND",
+                error: "Not found",
+            },
+        });
+        let dehydratedDeviceBody: any;
+        let dehydrationCount = 0;
+        let resolveDehydrationPromise: () => void;
+        fetchMock.put("path:/_matrix/client/unstable/org.matrix.msc3814.v1/dehydrated_device", (_, opts) => {
+            dehydratedDeviceBody = JSON.parse(opts.body as string);
+            dehydrationCount++;
+            if (resolveDehydrationPromise) {
+                resolveDehydrationPromise();
+            }
+            return {};
+        });
+        await crypto.startDehydration();
+
+        expect(dehydrationCount).toEqual(1);
+
+        // a week later, we should have created another dehydrated device
+        const dehydrationPromise = new Promise<void>((resolve, reject) => {
+            resolveDehydrationPromise = resolve;
+        });
+        jest.advanceTimersByTime(7 * 24 * 60 * 60 * 1000);
+        await dehydrationPromise;
+        expect(dehydrationCount).toEqual(2);
+
+        // restart dehydration -- rehydrate the device that we created above,
+        // and create a new dehydrated device.  We also set `createNewKey`, so
+        // a new dehydration key will be set
+        fetchMock.get("path:/_matrix/client/unstable/org.matrix.msc3814.v1/dehydrated_device", {
+            device_id: dehydratedDeviceBody.device_id,
+            device_data: dehydratedDeviceBody.device_data,
+        });
+        const eventsResponse = jest.fn((url, opts) => {
+            // rehydrating should make two calls to the /events endpoint.
+            // The first time will return a single event, and the second
+            // time will return no events (which will signal to the
+            // rehydration function that it can stop)
+            const body = JSON.parse(opts.body as string);
+            const nextBatch = body.next_batch ?? "0";
+            const events = nextBatch === "0" ? [{ sender: "@alice:localhost", type: "m.dummy", content: {} }] : [];
+            return {
+                events,
+                next_batch: nextBatch + "1",
+            };
+        });
+        fetchMock.post(
+            `path:/_matrix/client/unstable/org.matrix.msc3814.v1/dehydrated_device/${encodeURIComponent(dehydratedDeviceBody.device_id)}/events`,
+            eventsResponse,
+        );
+        await crypto.startDehydration(true);
+        expect(dehydrationCount).toEqual(3);
+
+        expect(setDehydrationCount).toEqual(2);
+        expect(eventsResponse.mock.calls).toHaveLength(2);
+
+        matrixClient.stopClient();
+    });
+});
+
+/** create a new secret storage and cross-signing keys */
+async function initializeSecretStorage(
+    matrixClient: MatrixClient,
+    userId: string,
+    homeserverUrl: string,
+): Promise<void> {
+    fetchMock.get("path:/_matrix/client/v3/room_keys/version", {
+        status: 404,
+        body: {
+            errcode: "M_NOT_FOUND",
+            error: "Not found",
+        },
+    });
+    const e2eKeyReceiver = new E2EKeyReceiver(homeserverUrl);
+    const e2eKeyResponder = new E2EKeyResponder(homeserverUrl);
+    e2eKeyResponder.addKeyReceiver(userId, e2eKeyReceiver);
+    fetchMock.post("path:/_matrix/client/v3/keys/device_signing/upload", {});
+    fetchMock.post("path:/_matrix/client/v3/keys/signatures/upload", {});
+    const accountData: Map<string, object> = new Map();
+    fetchMock.get("glob:http://*/_matrix/client/v3/user/*/account_data/*", (url, opts) => {
+        const name = url.split("/").pop()!;
+        const value = accountData.get(name);
+        if (value) {
+            return value;
+        } else {
+            return {
+                status: 404,
+                body: {
+                    errcode: "M_NOT_FOUND",
+                    error: "Not found",
+                },
+            };
+        }
+    });
+    fetchMock.put("glob:http://*/_matrix/client/v3/user/*/account_data/*", (url, opts) => {
+        const name = url.split("/").pop()!;
+        const value = JSON.parse(opts.body as string);
+        accountData.set(name, value);
+        matrixClient.emit(ClientEvent.AccountData, new MatrixEvent({ type: name, content: value }));
+        return {};
+    });
+
+    await matrixClient.initRustCrypto();
+    const crypto = matrixClient.getCrypto()! as RustCrypto;
+    // we need to process a sync so that the OlmMachine will upload keys
+    await crypto.preprocessToDeviceMessages([]);
+    await crypto.onSyncCompleted({});
+
+    // create initial secret storage
+    async function createSecretStorageKey() {
+        return {
+            keyInfo: {} as AddSecretStorageKeyOpts,
+            privateKey: new Uint8Array(32),
+        };
+    }
+    await matrixClient.bootstrapCrossSigning({ setupNewCrossSigning: true });
+    await matrixClient.bootstrapSecretStorage({
+        createSecretStorageKey,
+        setupNewSecretStorage: true,
+        setupNewKeyBackup: false,
+    });
+}

spec/integ/crypto/olm-encryption-spec.ts

@@ -0,0 +1,693 @@
+/*
+Copyright 2016 OpenMarket Ltd
+Copyright 2017 Vector Creations Ltd
+Copyright 2018 New Vector Ltd
+Copyright 2019 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/* This file consists of a set of integration tests which try to simulate
+ * communication via an Olm-encrypted room between two users, Alice and Bob.
+ *
+ * Note that megolm (group) conversation is not tested here.
+ *
+ * See also `crypto.spec.js`.
+ */
+
+// load olm before the sdk if possible
+import "../../olm-loader";
+
+import type { Session } from "@matrix-org/olm";
+import type { IDeviceKeys, IOneTimeKey } from "../../../src/@types/crypto";
+import { logger } from "../../../src/logger";
+import * as testUtils from "../../test-utils/test-utils";
+import { TestClient } from "../../TestClient";
+import { CRYPTO_ENABLED, IClaimKeysRequest, IQueryKeysRequest, IUploadKeysRequest } from "../../../src/client";
+import { ClientEvent, IContent, ISendEventResponse, MatrixClient, MatrixEvent, MsgType } from "../../../src/matrix";
+import { DeviceInfo } from "../../../src/crypto/deviceinfo";
+import { KnownMembership } from "../../../src/@types/membership";
+
+let aliTestClient: TestClient;
+const roomId = "!room:localhost";
+const aliUserId = "@ali:localhost";
+const aliDeviceId = "zxcvb";
+const aliAccessToken = "aseukfgwef";
+let bobTestClient: TestClient;
+const bobUserId = "@bob:localhost";
+const bobDeviceId = "bvcxz";
+const bobAccessToken = "fewgfkuesa";
+let aliMessages: IContent[];
+let bobMessages: IContent[];
+
+type OlmPayload = ReturnType<Session["encrypt"]>;
+
+async function bobUploadsDeviceKeys(): Promise<void> {
+    bobTestClient.expectDeviceKeyUpload();
+    await bobTestClient.httpBackend.flushAllExpected();
+    expect(Object.keys(bobTestClient.deviceKeys!).length).not.toEqual(0);
+}
+
+/**
+ * Set an expectation that querier will query uploader's keys; then flush the http request.
+ *
+ * @returns resolves once the http request has completed.
+ */
+function expectQueryKeys(querier: TestClient, uploader: TestClient): Promise<number> {
+    // can't query keys before bob has uploaded them
+    expect(uploader.deviceKeys).toBeTruthy();
+
+    const uploaderKeys: Record<string, IDeviceKeys> = {};
+    uploaderKeys[uploader.deviceId!] = uploader.deviceKeys!;
+    querier.httpBackend.when("POST", "/keys/query").respond(200, function (_path, content: IQueryKeysRequest) {
+        expect(content.device_keys![uploader.userId!]).toEqual([]);
+        const result: Record<string, Record<string, IDeviceKeys>> = {};
+        result[uploader.userId!] = uploaderKeys;
+        return { device_keys: result };
+    });
+    return querier.httpBackend.flush("/keys/query", 1);
+}
+const expectAliQueryKeys = () => expectQueryKeys(aliTestClient, bobTestClient);
+const expectBobQueryKeys = () => expectQueryKeys(bobTestClient, aliTestClient);
+
+/**
+ * Set an expectation that ali will claim one of bob's keys; then flush the http request.
+ *
+ * @returns resolves once the http request has completed.
+ */
+async function expectAliClaimKeys(): Promise<void> {
+    const keys = await bobTestClient.awaitOneTimeKeyUpload();
+    aliTestClient.httpBackend.when("POST", "/keys/claim").respond(200, function (_path, content: IClaimKeysRequest) {
+        const claimType = content.one_time_keys![bobUserId][bobDeviceId];
+        expect(claimType).toEqual("signed_curve25519");
+        let keyId = "";
+        for (keyId in keys) {
+            if (bobTestClient.oneTimeKeys!.hasOwnProperty(keyId)) {
+                if (keyId.indexOf(claimType + ":") === 0) {
+                    break;
+                }
+            }
+        }
+        const result: Record<string, Record<string, Record<string, IOneTimeKey>>> = {};
+        result[bobUserId] = {};
+        result[bobUserId][bobDeviceId] = {};
+        result[bobUserId][bobDeviceId][keyId] = keys[keyId];
+        return { one_time_keys: result };
+    });
+    // it can take a while to process the key query, so give it some extra
+    // time, and make sure the claim actually happens rather than ploughing on
+    // confusingly.
+    const r = await aliTestClient.httpBackend.flush("/keys/claim", 1, 500);
+    expect(r).toEqual(1);
+}
+
+async function aliDownloadsKeys(): Promise<void> {
+    // can't query keys before bob has uploaded them
+    expect(bobTestClient.getSigningKey()).toBeTruthy();
+
+    const p1 = async () => {
+        await aliTestClient.client.downloadKeys([bobUserId]);
+        const devices = aliTestClient.client.getStoredDevicesForUser(bobUserId);
+        expect(devices.length).toEqual(1);
+        expect(devices[0].deviceId).toEqual("bvcxz");
+    };
+    const p2 = expectAliQueryKeys;
+
+    // check that the localStorage is updated as we expect (not sure this is
+    // an integration test, but meh)
+    await Promise.all([p1(), p2()]);
+    await aliTestClient.client.crypto!.deviceList.saveIfDirty();
+    // @ts-ignore - protected
+    aliTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
+        const devices = data!.devices[bobUserId]!;
+        expect(devices[bobDeviceId].keys).toEqual(bobTestClient.deviceKeys!.keys);
+        expect(devices[bobDeviceId].verified).toBe(DeviceInfo.DeviceVerification.UNVERIFIED);
+    });
+}
+
+async function clientEnablesEncryption(client: MatrixClient): Promise<void> {
+    await client.setRoomEncryption(roomId, {
+        algorithm: "m.olm.v1.curve25519-aes-sha2",
+    });
+    expect(client.isRoomEncrypted(roomId)).toBeTruthy();
+}
+const aliEnablesEncryption = () => clientEnablesEncryption(aliTestClient.client);
+const bobEnablesEncryption = () => clientEnablesEncryption(bobTestClient.client);
+
+/**
+ * Ali sends a message, first claiming e2e keys. Set the expectations and
+ * check the results.
+ *
+ * @returns which resolves to the ciphertext for Bob's device.
+ */
+async function aliSendsFirstMessage(): Promise<OlmPayload> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_, ciphertext] = await Promise.all([
+        sendMessage(aliTestClient.client),
+        expectAliQueryKeys().then(expectAliClaimKeys).then(expectAliSendMessageRequest),
+    ]);
+    return ciphertext;
+}
+
+/**
+ * Ali sends a message without first claiming e2e keys. Set the expectations
+ * and check the results.
+ *
+ * @returns which resolves to the ciphertext for Bob's device.
+ */
+async function aliSendsMessage(): Promise<OlmPayload> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_, ciphertext] = await Promise.all([sendMessage(aliTestClient.client), expectAliSendMessageRequest()]);
+    return ciphertext;
+}
+
+/**
+ * Bob sends a message, first querying (but not claiming) e2e keys. Set the
+ * expectations and check the results.
+ *
+ * @returns which resolves to the ciphertext for Ali's device.
+ */
+async function bobSendsReplyMessage(): Promise<OlmPayload> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_, ciphertext] = await Promise.all([
+        sendMessage(bobTestClient.client),
+        expectBobQueryKeys().then(expectBobSendMessageRequest),
+    ]);
+    return ciphertext;
+}
+
+/**
+ * Set an expectation that Ali will send a message, and flush the request
+ *
+ * @returns which resolves to the ciphertext for Bob's device.
+ */
+async function expectAliSendMessageRequest(): Promise<OlmPayload> {
+    const content = await expectSendMessageRequest(aliTestClient.httpBackend);
+    aliMessages.push(content);
+    expect(Object.keys(content.ciphertext)).toEqual([bobTestClient.getDeviceKey()]);
+    const ciphertext = content.ciphertext[bobTestClient.getDeviceKey()];
+    expect(ciphertext).toBeTruthy();
+    return ciphertext;
+}
+
+/**
+ * Set an expectation that Bob will send a message, and flush the request
+ *
+ * @returns which resolves to the ciphertext for Bob's device.
+ */
+async function expectBobSendMessageRequest(): Promise<OlmPayload> {
+    const content = await expectSendMessageRequest(bobTestClient.httpBackend);
+    bobMessages.push(content);
+    const aliKeyId = "curve25519:" + aliDeviceId;
+    const aliDeviceCurve25519Key = aliTestClient.deviceKeys!.keys[aliKeyId];
+    expect(Object.keys(content.ciphertext)).toEqual([aliDeviceCurve25519Key]);
+    const ciphertext = content.ciphertext[aliDeviceCurve25519Key];
+    expect(ciphertext).toBeTruthy();
+    return ciphertext;
+}
+
+function sendMessage(client: MatrixClient): Promise<ISendEventResponse> {
+    return client.sendMessage(roomId, { msgtype: MsgType.Text, body: "Hello, World" });
+}
+
+async function expectSendMessageRequest(httpBackend: TestClient["httpBackend"]): Promise<IContent> {
+    const path = "/send/m.room.encrypted/";
+    const prom = new Promise<IContent>((resolve) => {
+        httpBackend.when("PUT", path).respond(200, function (_path, content) {
+            resolve(content);
+            return {
+                event_id: "asdfgh",
+            };
+        });
+    });
+
+    // it can take a while to process the key query
+    await httpBackend.flush(path, 1);
+    return prom;
+}
+
+function aliRecvMessage(): Promise<void> {
+    const message = bobMessages.shift()!;
+    return recvMessage(aliTestClient.httpBackend, aliTestClient.client, bobUserId, message);
+}
+
+function bobRecvMessage(): Promise<void> {
+    const message = aliMessages.shift()!;
+    return recvMessage(bobTestClient.httpBackend, bobTestClient.client, aliUserId, message);
+}
+
+async function recvMessage(
+    httpBackend: TestClient["httpBackend"],
+    client: MatrixClient,
+    sender: string,
+    message: IContent,
+): Promise<void> {
+    const syncData = {
+        next_batch: "x",
+        rooms: {
+            join: {
+                [roomId]: {
+                    timeline: {
+                        events: [
+                            testUtils.mkEvent({
+                                type: "m.room.encrypted",
+                                room: roomId,
+                                content: message,
+                                sender: sender,
+                            }),
+                        ],
+                    },
+                },
+            },
+        },
+    };
+    httpBackend.when("GET", "/sync").respond(200, syncData);
+
+    const eventPromise = new Promise<MatrixEvent>((resolve) => {
+        const onEvent = function (event: MatrixEvent) {
+            // ignore the m.room.member events
+            if (event.getType() == "m.room.member") {
+                return;
+            }
+            logger.log(client.credentials.userId + " received event", event);
+
+            client.removeListener(ClientEvent.Event, onEvent);
+            resolve(event);
+        };
+        client.on(ClientEvent.Event, onEvent);
+    });
+
+    await httpBackend.flushAllExpected();
+
+    const preDecryptionEvent = await eventPromise;
+    expect(preDecryptionEvent.isEncrypted()).toBeTruthy();
+    // it may still be being decrypted
+    const event = await testUtils.awaitDecryption(preDecryptionEvent);
+    expect(event.getType()).toEqual("m.room.message");
+    expect(event.getContent()).toMatchObject({
+        msgtype: "m.text",
+        body: "Hello, World",
+    });
+    expect(event.isEncrypted()).toBeTruthy();
+}
+
+/**
+ * Send an initial sync response to the client (which just includes the member
+ * list for our test room).
+ *
+ * @returns which resolves when the sync has been flushed.
+ */
+function firstSync(testClient: TestClient): Promise<void> {
+    // send a sync response including our test room.
+    const syncData = {
+        next_batch: "x",
+        rooms: {
+            join: {
+                [roomId]: {
+                    state: {
+                        events: [
+                            testUtils.mkMembership({
+                                mship: KnownMembership.Join,
+                                user: aliUserId,
+                            }),
+                            testUtils.mkMembership({
+                                mship: KnownMembership.Join,
+                                user: bobUserId,
+                            }),
+                        ],
+                    },
+                    timeline: {
+                        events: [],
+                    },
+                },
+            },
+        },
+    };
+
+    testClient.httpBackend.when("GET", "/sync").respond(200, syncData);
+    return testClient.flushSync();
+}
+
+describe("MatrixClient crypto", () => {
+    if (!CRYPTO_ENABLED) {
+        return;
+    }
+
+    beforeEach(async () => {
+        aliTestClient = new TestClient(aliUserId, aliDeviceId, aliAccessToken);
+        await aliTestClient.client.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(new Map());
+        await firstSync(aliTestClient);
+        await aliEnablesEncryption();
+        await aliSendsFirstMessage();
+        await bobRecvMessage();
+    });
+
+    it("Bob receives a message with a bogus sender", async () => {
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
+        await aliTestClient.start();
+        await bobTestClient.start();
+        bobTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve(new Map());
+        await firstSync(aliTestClient);
+        await aliEnablesEncryption();
+        await aliSendsFirstMessage();
+        const message = aliMessages.shift()!;
+        const syncData = {
+            next_batch: "x",
+            rooms: {
+                join: {
+                    [roomId]: {
+                        timeline: {
+                            events: [
+                                testUtils.mkEvent({
+                                    type: "m.room.encrypted",
+                                    room: roomId,
+                                    content: message,
+                                    sender: "@bogus:sender",
+                                }),
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+        bobTestClient.httpBackend.when("GET", "/sync").respond(200, syncData);
+
+        const eventPromise = new Promise<MatrixEvent>((resolve) => {
+            const onEvent = function (event: MatrixEvent) {
+                logger.log(bobUserId + " received event", event);
+                resolve(event);
+            };
+            bobTestClient.client.once(ClientEvent.Event, onEvent);
+        });
+        await bobTestClient.httpBackend.flushAllExpected();
+        const preDecryptionEvent = await eventPromise;
+        expect(preDecryptionEvent.isEncrypted()).toBeTruthy();
+        // it may still be being decrypted
+        const event = await testUtils.awaitDecryption(preDecryptionEvent);
+        expect(event.getType()).toEqual("m.room.message");
+        expect(event.getContent().msgtype).toEqual("m.bad.encrypted");
+    });
+
+    it("Ali blocks Bob's device", async () => {
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
+        await aliTestClient.start();
+        await bobTestClient.start();
+        await firstSync(aliTestClient);
+        await aliEnablesEncryption();
+        await aliDownloadsKeys();
+        aliTestClient.client.setDeviceBlocked(bobUserId, bobDeviceId, true);
+        const p1 = sendMessage(aliTestClient.client);
+        const p2 = expectSendMessageRequest(aliTestClient.httpBackend).then(function (sentContent) {
+            // no unblocked devices, so the ciphertext should be empty
+            expect(sentContent.ciphertext).toEqual({});
+        });
+        await Promise.all([p1, p2]);
+    });
+
+    it("Bob receives two pre-key messages", async () => {
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
+        await aliTestClient.start();
+        await bobTestClient.start();
+        bobTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve(new Map());
+        await firstSync(aliTestClient);
+        await aliEnablesEncryption();
+        await aliSendsFirstMessage();
+        await bobRecvMessage();
+        await aliSendsMessage();
+        await bobRecvMessage();
+    });
+
+    it("Bob replies to the message", async () => {
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
+        bobTestClient.expectKeyQuery({ device_keys: { [bobUserId]: {} }, failures: {} });
+        await aliTestClient.start();
+        await bobTestClient.start();
+        await firstSync(aliTestClient);
+        await firstSync(bobTestClient);
+        await aliEnablesEncryption();
+        await aliSendsFirstMessage();
+        bobTestClient.httpBackend.when("POST", "/keys/query").respond(200, {});
+        await bobRecvMessage();
+        await bobEnablesEncryption();
+        const ciphertext = await bobSendsReplyMessage();
+        expect(ciphertext.type).toEqual(1);
+        await aliRecvMessage();
+    });
+
+    it("Ali does a key query when encryption is enabled", async () => {
+        // enabling encryption in the room should make alice download devices
+        // for both members.
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
+        await aliTestClient.start();
+        await firstSync(aliTestClient);
+        const syncData = {
+            next_batch: "2",
+            rooms: {
+                join: {
+                    [roomId]: {
+                        state: {
+                            events: [
+                                testUtils.mkEvent({
+                                    type: "m.room.encryption",
+                                    skey: "",
+                                    content: {
+                                        algorithm: "m.olm.v1.curve25519-aes-sha2",
+                                    },
+                                }),
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+
+        aliTestClient.httpBackend.when("GET", "/sync").respond(200, syncData);
+        await aliTestClient.httpBackend.flush("/sync", 1);
+        aliTestClient.expectKeyQuery({
+            device_keys: {
+                [bobUserId]: {},
+            },
+            failures: {},
+        });
+        await aliTestClient.httpBackend.flushAllExpected();
+    });
+
+    it("Upload new oneTimeKeys based on a /sync request - no count-asking", async () => {
+        // Send a response which causes a key upload
+        const httpBackend = aliTestClient.httpBackend;
+        const syncDataEmpty = {
+            next_batch: "a",
+            device_one_time_keys_count: {
+                signed_curve25519: 0,
+            },
+        };
+
+        // enqueue expectations:
+        // * Sync with empty one_time_keys => upload keys
+
+        logger.log(aliTestClient + ": starting");
+        httpBackend.when("GET", "/versions").respond(200, {});
+        httpBackend.when("GET", "/pushrules").respond(200, {});
+        httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
+        aliTestClient.expectDeviceKeyUpload();
+
+        // we let the client do a very basic initial sync, which it needs before
+        // it will upload one-time keys.
+        httpBackend.when("GET", "/sync").respond(200, syncDataEmpty);
+
+        await Promise.all([aliTestClient.client.startClient({}), httpBackend.flushAllExpected()]);
+        logger.log(aliTestClient + ": started");
+        httpBackend.when("POST", "/keys/upload").respond(200, (_path, content: IUploadKeysRequest) => {
+            expect(content.one_time_keys).toBeTruthy();
+            expect(content.one_time_keys).not.toEqual({});
+            expect(Object.keys(content.one_time_keys!).length).toBeGreaterThanOrEqual(1);
+            // cancel futher calls by telling the client
+            // we have more than we need
+            return {
+                one_time_key_counts: {
+                    signed_curve25519: 70,
+                },
+            };
+        });
+        await httpBackend.flushAllExpected();
+    });
+
+    it("Checks for outgoing room key requests for a given event's session", async () => {
+        const eventA0 = new MatrixEvent({
+            sender: "@bob:example.com",
+            room_id: "!someroom",
+            content: {
+                algorithm: "m.megolm.v1.aes-sha2",
+                session_id: "sessionid",
+                sender_key: "senderkey",
+            },
+        });
+        const eventA1 = new MatrixEvent({
+            sender: "@bob:example.com",
+            room_id: "!someroom",
+            content: {
+                algorithm: "m.megolm.v1.aes-sha2",
+                session_id: "sessionid",
+                sender_key: "senderkey",
+            },
+        });
+        const eventB = new MatrixEvent({
+            sender: "@bob:example.com",
+            room_id: "!someroom",
+            content: {
+                algorithm: "m.megolm.v1.aes-sha2",
+                session_id: "othersessionid",
+                sender_key: "senderkey",
+            },
+        });
+        const nonEncryptedEvent = new MatrixEvent({
+            sender: "@bob:example.com",
+            room_id: "!someroom",
+            content: {},
+        });
+
+        aliTestClient.client.crypto?.onSyncCompleted({});
+        await aliTestClient.client.cancelAndResendEventRoomKeyRequest(eventA0);
+        expect(await aliTestClient.client.getOutgoingRoomKeyRequest(eventA1)).not.toBeNull();
+        expect(await aliTestClient.client.getOutgoingRoomKeyRequest(eventB)).toBeNull();
+        expect(await aliTestClient.client.getOutgoingRoomKeyRequest(nonEncryptedEvent)).toBeNull();
+    });
+});

spec/integ/crypto/olm-utils.ts

@@ -0,0 +1,408 @@
+/*
+Copyright 2016-2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import Olm from "@matrix-org/olm";
+import anotherjson from "another-json";
+
+import { IContent, IDeviceKeys, IDownloadKeyResult, IEvent, Keys, MatrixClient, SigningKeys } from "../../../src";
+import { IE2EKeyReceiver } from "../../test-utils/E2EKeyReceiver";
+import { ISyncResponder } from "../../test-utils/SyncResponder";
+import { syncPromise } from "../../test-utils/test-utils";
+import { KeyBackupInfo } from "../../../src/crypto-api";
+
+/**
+ * @module
+ *
+ * A set of utilities for creating Olm accounts and sessions, and encrypting/decrypting with Olm/Megolm.
+ */
+
+/** Create an Olm Account object */
+export async function createOlmAccount(): Promise<Olm.Account> {
+    await Olm.init();
+    const testOlmAccount = new Olm.Account();
+    testOlmAccount.create();
+    return testOlmAccount;
+}
+
+/**
+ * Get the device keys for the test Olm Account
+ *
+ * @param olmAccount - Test olm account
+ * @param userId - The user ID to present the keys as belonging to
+ */
+export function getTestOlmAccountKeys(olmAccount: Olm.Account, userId: string, deviceId: string): IDeviceKeys {
+    const testE2eKeys = JSON.parse(olmAccount.identity_keys());
+    const testDeviceKeys: IDeviceKeys = {
+        algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
+        device_id: deviceId,
+        keys: {
+            [`curve25519:${deviceId}`]: testE2eKeys.curve25519,
+            [`ed25519:${deviceId}`]: testE2eKeys.ed25519,
+        },
+        user_id: userId,
+    };
+
+    const j = anotherjson.stringify(testDeviceKeys);
+    const sig = olmAccount.sign(j);
+    testDeviceKeys.signatures = { [userId]: { [`ed25519:${deviceId}`]: sig } };
+    return testDeviceKeys;
+}
+
+/**
+ * Bootstrap cross signing for the given Olm account.
+ *
+ * Will generate the cross signing keys and sign them with the master key, and returns the `IDownloadKeyResult`
+ * that can be directly fed into a test e2eKeyResponder.
+ *
+ * The cross-signing keys are randomly generated, similar to how the olm account keys are generated. There may not
+ * be any value in using static vectors, as the device keys change at every test run.
+ *
+ * If some `KeyBackupInfo` are provided, the `auth_data` of each backup info will be signed with the
+ * master key, meaning the backups will be then trusted after verification.
+ *
+ * @param olmAccount - The Olm account object to use for signing the device keys.
+ * @param userId - The user ID to associate with the device keys.
+ * @param deviceId - The device ID to associate with the device keys.
+ * @param keyBackupInfo - Optional key backup infos to sign with the master key.
+ * @returns A valid keys/query response that can be fed into a test e2eKeyResponder.
+ */
+export function bootstrapCrossSigningTestOlmAccount(
+    olmAccount: Olm.Account,
+    userId: string,
+    deviceId: string,
+    keyBackupInfo: KeyBackupInfo[] = [],
+): Partial<IDownloadKeyResult> {
+    const olmAliceMSK = new global.Olm.PkSigning();
+    const masterPrivkey = olmAliceMSK.generate_seed();
+    const masterPubkey = olmAliceMSK.init_with_seed(masterPrivkey);
+
+    const olmAliceUSK = new global.Olm.PkSigning();
+    const userPrivkey = olmAliceUSK.generate_seed();
+    const userPubkey = olmAliceUSK.init_with_seed(userPrivkey);
+
+    const olmAliceSSK = new global.Olm.PkSigning();
+    const sskPrivkey = olmAliceSSK.generate_seed();
+    const sskPubkey = olmAliceSSK.init_with_seed(sskPrivkey);
+
+    const mskInfo: Keys = {
+        user_id: userId,
+        usage: ["master"],
+        keys: {
+            ["ed25519:" + masterPubkey]: masterPubkey,
+        },
+    };
+
+    const sskInfo: Partial<SigningKeys> = {
+        user_id: userId,
+        usage: ["self_signing"],
+        keys: {
+            ["ed25519:" + sskPubkey]: sskPubkey,
+        },
+    };
+    // sign the ssk with the msk
+    const sskSig = olmAliceMSK.sign(anotherjson.stringify(sskInfo));
+    sskInfo.signatures = {
+        [userId]: {
+            ["ed25519:" + masterPubkey]: sskSig,
+        },
+    };
+
+    const uskInfo: Partial<SigningKeys> = {
+        user_id: userId,
+        usage: ["user_signing"],
+        keys: {
+            ["ed25519:" + userPubkey]: userPubkey,
+        },
+    };
+
+    // sign the usk with the msk
+    const uskSig = olmAliceMSK.sign(anotherjson.stringify(uskInfo));
+    uskInfo.signatures = {
+        [userId]: {
+            ["ed25519:" + masterPubkey]: uskSig,
+        },
+    };
+
+    // get the device keys and sign them with the ssk (the device is then cross signed)
+    const deviceKeys = getTestOlmAccountKeys(olmAccount, userId, deviceId);
+
+    const copy = Object.assign({}, deviceKeys);
+    delete copy.signatures;
+    const crossSignature = olmAliceSSK.sign(anotherjson.stringify(copy));
+
+    // add the signature
+    deviceKeys.signatures![userId]["ed25519:" + sskPubkey] = crossSignature;
+
+    // if we have some key backup info, sign them with the msk
+    keyBackupInfo.forEach((info) => {
+        const unsignedAuthData = Object.assign({}, info.auth_data);
+        delete unsignedAuthData.signatures;
+        const backupSignature = olmAliceMSK.sign(anotherjson.stringify(unsignedAuthData));
+
+        info.auth_data.signatures = {
+            [userId]: {
+                ["ed25519:" + masterPubkey]: backupSignature,
+            },
+        };
+    });
+
+    // clean the olm resources as we don't need them anymore
+    olmAliceMSK.free();
+    olmAliceSSK.free();
+    olmAliceUSK.free();
+
+    return {
+        master_keys: { [userId]: mskInfo },
+        user_signing_keys: { [userId]: uskInfo as SigningKeys },
+        self_signing_keys: { [userId]: sskInfo as SigningKeys },
+        device_keys: { [userId]: { [deviceId]: deviceKeys } },
+    };
+}
+
+/** start an Olm session with a given recipient */
+export async function createOlmSession(
+    olmAccount: Olm.Account,
+    recipientTestClient: IE2EKeyReceiver,
+): Promise<Olm.Session> {
+    const keys = await recipientTestClient.awaitOneTimeKeyUpload();
+    const otkId = Object.keys(keys)[0];
+    const otk = keys[otkId];
+
+    const session = new global.Olm.Session();
+    session.create_outbound(olmAccount, recipientTestClient.getDeviceKey(), otk.key);
+    return session;
+}
+
+// IToDeviceEvent isn't exported by src/sync-accumulator.ts
+export interface ToDeviceEvent {
+    content: IContent;
+    sender: string;
+    type: string;
+}
+
+/** encrypt an event with an existing olm session */
+export function encryptOlmEvent(opts: {
+    /** the sender's user id */
+    sender?: string;
+    /** the sender's curve25519 key */
+    senderKey: string;
+    /** the sender's ed25519 key */
+    senderSigningKey: string;
+    /** the olm session to use for encryption */
+    p2pSession: Olm.Session;
+    /** the recipient's user id */
+    recipient: string;
+    /** the recipient's curve25519 key */
+    recipientCurve25519Key: string;
+    /** the recipient's ed25519 key */
+    recipientEd25519Key: string;
+    /** the payload of the message */
+    plaincontent?: object;
+    /** the event type of the payload */
+    plaintype?: string;
+}): ToDeviceEvent {
+    expect(opts.senderKey).toBeTruthy();
+    expect(opts.p2pSession).toBeTruthy();
+    expect(opts.recipient).toBeTruthy();
+
+    const plaintext = {
+        content: opts.plaincontent || {},
+        recipient: opts.recipient,
+        recipient_keys: {
+            ed25519: opts.recipientEd25519Key,
+        },
+        keys: {
+            ed25519: opts.senderSigningKey,
+        },
+        sender: opts.sender || "@bob:xyz",
+        type: opts.plaintype || "m.test",
+    };
+
+    return {
+        content: {
+            algorithm: "m.olm.v1.curve25519-aes-sha2",
+            ciphertext: {
+                [opts.recipientCurve25519Key]: opts.p2pSession.encrypt(JSON.stringify(plaintext)),
+            },
+            sender_key: opts.senderKey,
+        },
+        sender: opts.sender || "@bob:xyz",
+        type: "m.room.encrypted",
+    };
+}
+
+// encrypt an event with megolm
+export function encryptMegolmEvent(opts: {
+    senderKey: string;
+    groupSession: Olm.OutboundGroupSession;
+    plaintext?: Partial<IEvent>;
+    room_id?: string;
+}): IEvent {
+    expect(opts.senderKey).toBeTruthy();
+    expect(opts.groupSession).toBeTruthy();
+
+    const plaintext = opts.plaintext || {};
+    if (!plaintext.content) {
+        plaintext.content = {
+            body: "42",
+            msgtype: "m.text",
+        };
+    }
+    if (!plaintext.type) {
+        plaintext.type = "m.room.message";
+    }
+    if (!plaintext.room_id) {
+        expect(opts.room_id).toBeTruthy();
+        plaintext.room_id = opts.room_id;
+    }
+    return encryptMegolmEventRawPlainText({
+        senderKey: opts.senderKey,
+        groupSession: opts.groupSession,
+        plaintext,
+    });
+}
+
+export function encryptMegolmEventRawPlainText(opts: {
+    senderKey: string;
+    groupSession: Olm.OutboundGroupSession;
+    plaintext: Partial<IEvent>;
+    origin_server_ts?: number;
+}): IEvent {
+    return {
+        event_id: "$test_megolm_event_" + Math.random(),
+        sender: opts.plaintext.sender ?? "@not_the_real_sender:example.com",
+        origin_server_ts: opts.plaintext.origin_server_ts ?? 1672944778000,
+        content: {
+            algorithm: "m.megolm.v1.aes-sha2",
+            ciphertext: opts.groupSession.encrypt(JSON.stringify(opts.plaintext)),
+            device_id: "testDevice",
+            sender_key: opts.senderKey,
+            session_id: opts.groupSession.session_id(),
+        },
+        type: "m.room.encrypted",
+        unsigned: {},
+    };
+}
+
+/** build an encrypted room_key event to share a group session, using an existing olm session */
+export function encryptGroupSessionKey(opts: {
+    /** recipient's user id */
+    recipient: string;
+    /** the recipient's curve25519 key */
+    recipientCurve25519Key: string;
+    /** the recipient's ed25519 key */
+    recipientEd25519Key: string;
+    /** sender's olm account */
+    olmAccount: Olm.Account;
+    /** sender's olm session with the recipient */
+    p2pSession: Olm.Session;
+    groupSession: Olm.OutboundGroupSession;
+    room_id?: string;
+}): ToDeviceEvent {
+    const senderKeys = JSON.parse(opts.olmAccount.identity_keys());
+    return encryptOlmEvent({
+        senderKey: senderKeys.curve25519,
+        senderSigningKey: senderKeys.ed25519,
+        recipient: opts.recipient,
+        recipientCurve25519Key: opts.recipientCurve25519Key,
+        recipientEd25519Key: opts.recipientEd25519Key,
+        p2pSession: opts.p2pSession,
+        plaincontent: {
+            algorithm: "m.megolm.v1.aes-sha2",
+            room_id: opts.room_id,
+            session_id: opts.groupSession.session_id(),
+            session_key: opts.groupSession.session_key(),
+        },
+        plaintype: "m.room_key",
+    });
+}
+
+/**
+ * Test utility to correctly encrypt a secret send event to a test device using the provided p2p session.
+ *
+ * @param opts - the options for the secret send event
+ * @returns the to-device event, ready to be returned in a sync response for the test device.
+ */
+export function encryptSecretSend(opts: {
+    /** the sender's user id */
+    sender: string;
+    /** recipient's user id */
+    recipient: string;
+    /** the recipient's curve25519 key */
+    recipientCurve25519Key: string;
+    /** the recipient's ed25519 key */
+    recipientEd25519Key: string;
+    /** sender's olm account */
+    olmAccount: Olm.Account;
+    /** sender's olm session with the recipient */
+    p2pSession: Olm.Session;
+    /** The requestId of the secret request that this secret send is replying. */
+    requestId: string;
+    /** The secret value */
+    secret: string;
+}): ToDeviceEvent {
+    const senderKeys = JSON.parse(opts.olmAccount.identity_keys());
+    return encryptOlmEvent({
+        sender: opts.sender,
+        senderKey: senderKeys.curve25519,
+        senderSigningKey: senderKeys.ed25519,
+        recipient: opts.recipient,
+        recipientCurve25519Key: opts.recipientCurve25519Key,
+        recipientEd25519Key: opts.recipientEd25519Key,
+        p2pSession: opts.p2pSession,
+        plaincontent: {
+            request_id: opts.requestId,
+            secret: opts.secret,
+        },
+        plaintype: "m.secret.send",
+    });
+}
+
+/**
+ * Establish an Olm Session with the test user
+ *
+ * Waits for the test user to upload their keys, then sends a /sync response with a to-device message which will
+ * establish an Olm session.
+ *
+ * @param testClient - the MatrixClient under test, which we expect to upload account keys, and to make a
+ *    /sync request which we will respond to.
+ * @param keyReceiver - an IE2EKeyReceiver which will intercept the /keys/upload request from the client under test
+ * @param syncResponder - an ISyncResponder which will intercept /sync requests from the client under test
+ * @param peerOlmAccount: an OlmAccount which will be used to initiate the Olm session.
+ */
+export async function establishOlmSession(
+    testClient: MatrixClient,
+    keyReceiver: IE2EKeyReceiver,
+    syncResponder: ISyncResponder,
+    peerOlmAccount: Olm.Account,
+): Promise<Olm.Session> {
+    const peerE2EKeys = JSON.parse(peerOlmAccount.identity_keys());
+    const p2pSession = await createOlmSession(peerOlmAccount, keyReceiver);
+    const olmEvent = encryptOlmEvent({
+        senderKey: peerE2EKeys.curve25519,
+        senderSigningKey: peerE2EKeys.ed25519,
+        recipient: testClient.getUserId()!,
+        recipientCurve25519Key: keyReceiver.getDeviceKey(),
+        recipientEd25519Key: keyReceiver.getSigningKey(),
+        p2pSession: p2pSession,
+    });
+    syncResponder.sendOrQueueSyncResponse({
+        next_batch: 1,
+        to_device: { events: [olmEvent] },
+    });
+    await syncPromise(testClient);
+    return p2pSession;
+}

spec/integ/crypto/rust-crypto.spec.ts

@@ -0,0 +1,477 @@
+/*
+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 fetchMock from "fetch-mock-jest";
+
+import { createClient, CryptoEvent, IndexedDBCryptoStore } from "../../../src";
+import { populateStore } from "../../test-utils/test_indexeddb_cryptostore_dump";
+import { MSK_NOT_CACHED_DATASET } from "../../test-utils/test_indexeddb_cryptostore_dump/no_cached_msk_dump";
+import { IDENTITY_NOT_TRUSTED_DATASET } from "../../test-utils/test_indexeddb_cryptostore_dump/unverified";
+import { FULL_ACCOUNT_DATASET } from "../../test-utils/test_indexeddb_cryptostore_dump/full_account";
+import { EMPTY_ACCOUNT_DATASET } from "../../test-utils/test_indexeddb_cryptostore_dump/empty_account";
+
+jest.setTimeout(15000);
+
+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 db", 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 an indexed db now
+        const databaseNames = (await indexedDB.databases()).map((db) => db.name);
+        expect(databaseNames).toEqual(expect.arrayContaining(["matrix-js-sdk::matrix-sdk-crypto"]));
+    });
+
+    it("should create the meta db if given a storageKey", async () => {
+        const matrixClient = createClient({
+            baseUrl: "http://test.server",
+            userId: "@alice:localhost",
+            deviceId: "aliceDevice",
+        });
+
+        // No databases.
+        expect(await indexedDB.databases()).toHaveLength(0);
+
+        await matrixClient.initRustCrypto({ storageKey: new Uint8Array(32) });
+
+        // should have two indexed 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 create the meta db if given a storagePassword", async () => {
+        const matrixClient = createClient({
+            baseUrl: "http://test.server",
+            userId: "@alice:localhost",
+            deviceId: "aliceDevice",
+        });
+
+        // No databases.
+        expect(await indexedDB.databases()).toHaveLength(0);
+
+        await matrixClient.initRustCrypto({ storagePassword: "the cow is on the moon" });
+
+        // should have two indexed 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("Libolm Migration", () => {
+        beforeEach(() => {
+            fetchMock.reset();
+        });
+
+        it("should migrate from libolm", async () => {
+            fetchMock.get("path:/_matrix/client/v3/room_keys/version", FULL_ACCOUNT_DATASET.backupResponse);
+
+            fetchMock.post("path:/_matrix/client/v3/keys/query", FULL_ACCOUNT_DATASET.keyQueryResponse);
+
+            const testStoreName = "test-store";
+            await populateStore(testStoreName, FULL_ACCOUNT_DATASET.dumpPath);
+            const cryptoStore = new IndexedDBCryptoStore(indexedDB, testStoreName);
+
+            const matrixClient = createClient({
+                baseUrl: "http://test.server",
+                userId: FULL_ACCOUNT_DATASET.userId,
+                deviceId: FULL_ACCOUNT_DATASET.deviceId,
+                cryptoStore,
+                pickleKey: FULL_ACCOUNT_DATASET.pickleKey,
+            });
+
+            const progressListener = jest.fn();
+            matrixClient.addListener(CryptoEvent.LegacyCryptoStoreMigrationProgress, progressListener);
+
+            await matrixClient.initRustCrypto();
+
+            const verificationStatus = await matrixClient
+                .getCrypto()!
+                .getDeviceVerificationStatus(FULL_ACCOUNT_DATASET.userId, FULL_ACCOUNT_DATASET.deviceId);
+
+            // Check that the current device and identity trust is migrated correctly just after migration
+            expect(verificationStatus).toBeDefined();
+            expect(verificationStatus!.crossSigningVerified).toEqual(true);
+            expect(verificationStatus!.signedByOwner).toEqual(true);
+
+            // Do some basic checks on the imported data
+            const deviceKeys = await matrixClient.getCrypto()!.getOwnDeviceKeys();
+            expect(deviceKeys.curve25519).toEqual("LKv0bKbc0EC4h0jknbemv3QalEkeYvuNeUXVRgVVTTU");
+            expect(deviceKeys.ed25519).toEqual("qK70DEqIXq7T+UU3v/al47Ab4JkMEBLpNrTBMbS5rrw");
+
+            expect(await matrixClient.getCrypto()!.getActiveSessionBackupVersion()).toEqual("7");
+
+            expect(await matrixClient.getCrypto()!.isEncryptionEnabledInRoom("!CWLUCoEWXSFyTCOtfL:matrix.org")).toBe(
+                true,
+            );
+
+            // check the progress callback
+            expect(progressListener.mock.calls.length).toBeGreaterThan(50);
+
+            // The first call should have progress == 0
+            const [firstProgress, totalSteps] = progressListener.mock.calls[0];
+            expect(totalSteps).toBeGreaterThan(3000);
+            expect(firstProgress).toEqual(0);
+
+            for (let i = 1; i < progressListener.mock.calls.length - 1; i++) {
+                const [progress, total] = progressListener.mock.calls[i];
+                expect(total).toEqual(totalSteps);
+                expect(progress).toBeGreaterThan(progressListener.mock.calls[i - 1][0]);
+                expect(progress).toBeLessThanOrEqual(totalSteps);
+            }
+
+            // The final call should have progress == total == -1
+            expect(progressListener).toHaveBeenLastCalledWith(-1, -1);
+        }, 60000);
+
+        describe("Private key backup migration", () => {
+            it("should not migrate the backup private key if backup has changed", async () => {
+                // Here we have a new backup server side, and the migrated account has the previous backup key.
+                fetchMock.get("path:/_matrix/client/v3/room_keys/version", MSK_NOT_CACHED_DATASET.newBackupResponse);
+
+                fetchMock.post("path:/_matrix/client/v3/keys/query", MSK_NOT_CACHED_DATASET.keyQueryResponse);
+
+                await populateStore("test-store", MSK_NOT_CACHED_DATASET.dumpPath);
+                const cryptoStore = new IndexedDBCryptoStore(indexedDB, "test-store");
+
+                const matrixClient = createClient({
+                    baseUrl: "http://test.server",
+                    userId: MSK_NOT_CACHED_DATASET.userId,
+                    deviceId: MSK_NOT_CACHED_DATASET.deviceId,
+                    cryptoStore,
+                    pickleKey: MSK_NOT_CACHED_DATASET.pickleKey,
+                });
+
+                await matrixClient.initRustCrypto();
+
+                const privateBackupKey = await matrixClient.getCrypto()?.getSessionBackupPrivateKey();
+                expect(privateBackupKey).toBeNull();
+            });
+
+            it("should not migrate the backup private key if backup has unknown algorithm", async () => {
+                // Here we have a new backup server side, and the migrated account has the previous backup key.
+                const backupResponse = {
+                    ...MSK_NOT_CACHED_DATASET.backupResponse,
+                    algorithm: "m.megolm_backup.v8",
+                };
+                fetchMock.get("path:/_matrix/client/v3/room_keys/version", backupResponse);
+
+                fetchMock.post("path:/_matrix/client/v3/keys/query", MSK_NOT_CACHED_DATASET.keyQueryResponse);
+
+                await populateStore("test-store", MSK_NOT_CACHED_DATASET.dumpPath);
+                const cryptoStore = new IndexedDBCryptoStore(indexedDB, "test-store");
+
+                const matrixClient = createClient({
+                    baseUrl: "http://test.server",
+                    userId: MSK_NOT_CACHED_DATASET.userId,
+                    deviceId: MSK_NOT_CACHED_DATASET.deviceId,
+                    cryptoStore,
+                    pickleKey: MSK_NOT_CACHED_DATASET.pickleKey,
+                });
+
+                await matrixClient.initRustCrypto();
+
+                const privateBackupKey = await matrixClient.getCrypto()?.getSessionBackupPrivateKey();
+                expect(privateBackupKey).toBeNull();
+            });
+
+            it("should not migrate the backup private key if the backup has been deleted", async () => {
+                // The old backup has been deleted server side.
+                fetchMock.get("path:/_matrix/client/v3/room_keys/version", {
+                    status: 404,
+                    body: {
+                        errcode: "M_NOT_FOUND",
+                        error: "No backup found",
+                    },
+                });
+
+                fetchMock.post("path:/_matrix/client/v3/keys/query", MSK_NOT_CACHED_DATASET.keyQueryResponse);
+
+                await populateStore("test-store", MSK_NOT_CACHED_DATASET.dumpPath);
+                const cryptoStore = new IndexedDBCryptoStore(indexedDB, "test-store");
+
+                const matrixClient = createClient({
+                    baseUrl: "http://test.server",
+                    userId: MSK_NOT_CACHED_DATASET.userId,
+                    deviceId: MSK_NOT_CACHED_DATASET.deviceId,
+                    cryptoStore,
+                    pickleKey: MSK_NOT_CACHED_DATASET.pickleKey,
+                });
+
+                await matrixClient.initRustCrypto();
+
+                const privateBackupKey = await matrixClient.getCrypto()?.getSessionBackupPrivateKey();
+                expect(privateBackupKey).toBeNull();
+            });
+
+            it("should migrate the backup private key if the backup matches", async () => {
+                // The old backup has been deleted server side.
+                fetchMock.get("path:/_matrix/client/v3/room_keys/version", MSK_NOT_CACHED_DATASET.backupResponse);
+
+                fetchMock.post("path:/_matrix/client/v3/keys/query", MSK_NOT_CACHED_DATASET.keyQueryResponse);
+
+                await populateStore("test-store", MSK_NOT_CACHED_DATASET.dumpPath);
+                const cryptoStore = new IndexedDBCryptoStore(indexedDB, "test-store");
+
+                const matrixClient = createClient({
+                    baseUrl: "http://test.server",
+                    userId: MSK_NOT_CACHED_DATASET.userId,
+                    deviceId: MSK_NOT_CACHED_DATASET.deviceId,
+                    cryptoStore,
+                    pickleKey: MSK_NOT_CACHED_DATASET.pickleKey,
+                });
+
+                await matrixClient.initRustCrypto();
+
+                const privateBackupKey = await matrixClient.getCrypto()?.getSessionBackupPrivateKey();
+                expect(privateBackupKey).toBeDefined();
+            });
+        });
+
+        it("should not migrate if account data is missing", async () => {
+            // See https://github.com/element-hq/element-web/issues/27447
+
+            // Given we have an almost-empty legacy account in the database
+            fetchMock.get("path:/_matrix/client/v3/room_keys/version", {
+                status: 404,
+                body: { errcode: "M_NOT_FOUND", error: "No backup found" },
+            });
+            fetchMock.post("path:/_matrix/client/v3/keys/query", EMPTY_ACCOUNT_DATASET.keyQueryResponse);
+
+            const testStoreName = "test-store";
+            await populateStore(testStoreName, EMPTY_ACCOUNT_DATASET.dumpPath);
+            const cryptoStore = new IndexedDBCryptoStore(indexedDB, testStoreName);
+
+            const matrixClient = createClient({
+                baseUrl: "http://test.server",
+                userId: EMPTY_ACCOUNT_DATASET.userId,
+                deviceId: EMPTY_ACCOUNT_DATASET.deviceId,
+                cryptoStore,
+                pickleKey: EMPTY_ACCOUNT_DATASET.pickleKey,
+            });
+
+            // When we start Rust crypto, potentially triggering an upgrade
+            const progressListener = jest.fn();
+            matrixClient.addListener(CryptoEvent.LegacyCryptoStoreMigrationProgress, progressListener);
+
+            await matrixClient.initRustCrypto();
+
+            // Then no error occurs, and no upgrade happens
+            expect(progressListener.mock.calls.length).toBe(0);
+        }, 60000);
+
+        describe("Legacy trust migration", () => {
+            async function populateAndStartLegacyCryptoStore(dumpPath: string): Promise<IndexedDBCryptoStore> {
+                const testStoreName = "test-store";
+                await populateStore(testStoreName, dumpPath);
+                const cryptoStore = new IndexedDBCryptoStore(indexedDB, testStoreName);
+                await cryptoStore.startup();
+                return cryptoStore;
+            }
+
+            it("should not revert to untrusted if legacy was trusted but msk not in cache, big account", async () => {
+                fetchMock.get("path:/_matrix/client/v3/room_keys/version", {
+                    status: 404,
+                    body: {
+                        errcode: "M_NOT_FOUND",
+                        error: "No backup found",
+                    },
+                });
+
+                fetchMock.post("path:/_matrix/client/v3/keys/query", FULL_ACCOUNT_DATASET.keyQueryResponse);
+
+                const cryptoStore = await populateAndStartLegacyCryptoStore(FULL_ACCOUNT_DATASET.dumpPath);
+
+                // Remove the master key from the cache
+                await cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+                    const objectStore = txn.objectStore("account");
+                    objectStore.delete(`ssss_cache:master`);
+                });
+
+                const matrixClient = createClient({
+                    baseUrl: "http://test.server",
+                    userId: FULL_ACCOUNT_DATASET.userId,
+                    deviceId: FULL_ACCOUNT_DATASET.deviceId,
+                    cryptoStore,
+                    pickleKey: FULL_ACCOUNT_DATASET.pickleKey,
+                });
+
+                await matrixClient.initRustCrypto();
+
+                const verificationStatus = await matrixClient
+                    .getCrypto()!
+                    .getUserVerificationStatus(FULL_ACCOUNT_DATASET.userId);
+
+                expect(verificationStatus.isCrossSigningVerified()).toBe(true);
+            }, 60000);
+
+            it("should not revert to untrusted if legacy was trusted but msk not in cache", async () => {
+                fetchMock.get("path:/_matrix/client/v3/room_keys/version", MSK_NOT_CACHED_DATASET.backupResponse);
+
+                fetchMock.post("path:/_matrix/client/v3/keys/query", MSK_NOT_CACHED_DATASET.keyQueryResponse);
+
+                const cryptoStore = await populateAndStartLegacyCryptoStore(MSK_NOT_CACHED_DATASET.dumpPath);
+
+                const matrixClient = createClient({
+                    baseUrl: "http://test.server",
+                    userId: MSK_NOT_CACHED_DATASET.userId,
+                    deviceId: MSK_NOT_CACHED_DATASET.deviceId,
+                    cryptoStore,
+                    pickleKey: MSK_NOT_CACHED_DATASET.pickleKey,
+                });
+
+                await matrixClient.initRustCrypto();
+
+                const verificationStatus = await matrixClient
+                    .getCrypto()!
+                    .getUserVerificationStatus("@migration:localhost");
+
+                expect(verificationStatus.isCrossSigningVerified()).toBe(true);
+            });
+
+            it("should not migrate local trust if key has changed", async () => {
+                fetchMock.get("path:/_matrix/client/v3/room_keys/version", MSK_NOT_CACHED_DATASET.backupResponse);
+
+                fetchMock.post("path:/_matrix/client/v3/keys/query", MSK_NOT_CACHED_DATASET.rotatedKeyQueryResponse);
+
+                const cryptoStore = await populateAndStartLegacyCryptoStore(MSK_NOT_CACHED_DATASET.dumpPath);
+
+                const matrixClient = createClient({
+                    baseUrl: "http://test.server",
+                    userId: MSK_NOT_CACHED_DATASET.userId,
+                    deviceId: MSK_NOT_CACHED_DATASET.deviceId,
+                    cryptoStore,
+                    pickleKey: MSK_NOT_CACHED_DATASET.pickleKey,
+                });
+
+                await matrixClient.initRustCrypto();
+
+                const verificationStatus = await matrixClient
+                    .getCrypto()!
+                    .getUserVerificationStatus("@migration:localhost");
+
+                expect(verificationStatus.isCrossSigningVerified()).toBe(false);
+            });
+
+            it("should not migrate local trust if was not trusted in legacy", async () => {
+                // Just 404 here for the test
+                fetchMock.get("path:/_matrix/client/v3/room_keys/version", {
+                    status: 404,
+                    body: {
+                        errcode: "M_NOT_FOUND",
+                        error: "No backup found",
+                    },
+                });
+
+                fetchMock.post("path:/_matrix/client/v3/keys/query", IDENTITY_NOT_TRUSTED_DATASET.keyQueryResponse);
+
+                const cryptoStore = await populateAndStartLegacyCryptoStore(IDENTITY_NOT_TRUSTED_DATASET.dumpPath);
+
+                const matrixClient = createClient({
+                    baseUrl: "http://test.server",
+                    userId: IDENTITY_NOT_TRUSTED_DATASET.userId,
+                    deviceId: IDENTITY_NOT_TRUSTED_DATASET.deviceId,
+                    cryptoStore,
+                    pickleKey: IDENTITY_NOT_TRUSTED_DATASET.pickleKey,
+                });
+
+                await matrixClient.initRustCrypto();
+
+                const verificationStatus = await matrixClient
+                    .getCrypto()!
+                    .getUserVerificationStatus("@untrusted:localhost");
+
+                expect(verificationStatus.isCrossSigningVerified()).toBe(false);
+            });
+        });
+    });
+});
+
+describe("MatrixClient.clearStores", () => {
+    it("should clear the indexeddbs", async () => {
+        const matrixClient = createClient({
+            baseUrl: "http://test.server",
+            userId: "@alice:localhost",
+            deviceId: "aliceDevice",
+        });
+
+        await matrixClient.initRustCrypto({ storagePassword: "testKey" });
+        expect(await indexedDB.databases()).toHaveLength(2);
+        await matrixClient.stopClient();
+
+        await matrixClient.clearStores();
+        expect(await indexedDB.databases()).toHaveLength(0);
+    });
+
+    it("should not fail in environments without indexedDB", async () => {
+        // eslint-disable-next-line no-global-assign
+        indexedDB = undefined!;
+        const matrixClient = createClient({
+            baseUrl: "http://test.server",
+            userId: "@alice:localhost",
+            deviceId: "aliceDevice",
+        });
+
+        await matrixClient.stopClient();
+
+        await matrixClient.clearStores();
+        // No error thrown in clearStores
+    });
+});

spec/integ/devicelist-integ-spec.js

@@ -1,396 +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';
-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("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.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.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.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.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);
-               });
-           });
-       }).timeout(3000);
-
-    // 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.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.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.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.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,406 @@
+/*
+Copyright 2017 Vector Creations Ltd
+Copyright 2018 New Vector Ltd
+Copyright 2019 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { TestClient } from "../TestClient";
+import * as testUtils from "../test-utils/test-utils";
+import { logger } from "../../src/logger";
+import { KnownMembership } from "../../src/@types/membership";
+
+const ROOM_ID = "!room:id";
+
+/**
+ * get a /sync response which contains a single e2e room (ROOM_ID), with the
+ * members given
+ *
+ * @returns sync response
+ */
+function getSyncResponse(roomMembers: string[]) {
+    const stateEvents = [
+        testUtils.mkEvent({
+            type: "m.room.encryption",
+            skey: "",
+            content: {
+                algorithm: "m.megolm.v1.aes-sha2",
+            },
+        }),
+    ];
+
+    Array.prototype.push.apply(
+        stateEvents,
+        roomMembers.map((m) =>
+            testUtils.mkMembership({
+                mship: KnownMembership.Join,
+                sender: m,
+            }),
+        ),
+    );
+
+    const syncResponse = {
+        next_batch: 1,
+        rooms: {
+            join: {
+                [ROOM_ID]: {
+                    state: {
+                        events: stateEvents,
+                    },
+                },
+            },
+        },
+    };
+
+    return syncResponse;
+}
+
+describe("DeviceList management:", function () {
+    if (!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: KnownMembership.Leave,
+                                        sender: "@bob:xyz",
+                                    }),
+                                ],
+                            },
+                        },
+                    },
+                },
+            });
+
+            await aliceTestClient.flushSync();
+            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
+
+            // @ts-ignore accessing a protected field
+            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                const bobStat = data!.trackingStatus["@bob:xyz"];
+
+                // Alice should have marked bob's device list as untracked
+                expect(bobStat).toEqual(0);
+            });
+        });
+
+        it("when Alice leaves", async function () {
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
+                next_batch: 2,
+                device_lists: {
+                    left: ["@bob:xyz"],
+                },
+                rooms: {
+                    leave: {
+                        [ROOM_ID]: {
+                            timeline: {
+                                events: [
+                                    testUtils.mkMembership({
+                                        mship: KnownMembership.Leave,
+                                        sender: "@bob:xyz",
+                                    }),
+                                ],
+                            },
+                        },
+                    },
+                },
+            });
+
+            await aliceTestClient.flushSync();
+            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
+
+            // @ts-ignore accessing a protected field
+            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                const bobStat = data!.trackingStatus["@bob:xyz"];
+
+                // Alice should have marked bob's device list as untracked
+                expect(bobStat).toEqual(0);
+            });
+        });
+
+        it("when Bob leaves whilst Alice is offline", async function () {
+            aliceTestClient.stop();
+
+            const anotherTestClient = await createTestClient();
+
+            try {
+                await anotherTestClient.start();
+                anotherTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse([]));
+                await anotherTestClient.flushSync();
+                await anotherTestClient.client?.crypto?.deviceList?.saveIfDirty();
+
+                // @ts-ignore accessing private property
+                anotherTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
+                    const bobStat = data!.trackingStatus["@bob:xyz"];
+
+                    // Alice should have marked bob's device list as untracked
+                    expect(bobStat).toEqual(0);
+                });
+            } finally {
+                anotherTestClient.stop();
+            }
+        });
+    });
+});

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

@@ -1,757 +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";
-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.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()).toEqual({
-            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", "/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,330 +0,0 @@
-import * as utils from "../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", "/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,361 @@
+/*
+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";
+import { KnownMembership } from "../../src/@types/membership";
+
+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: KnownMembership.Join,
+                                    user: "@foo:bar",
+                                }),
+                                utils.mkEvent({
+                                    type: "m.room.create",
+                                    room: "!erufh:bar",
+                                    user: "@foo:bar",
+                                    content: {},
+                                }),
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+        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", async () => {
+            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();
+
+            await httpBackend!.flushAllExpected();
+            expect(fired).toBe(true);
+        });
+
+        it("should emit User events when presence data is absent in first sync", async () => {
+            const MODIFIED_SYNC_DATA: any = structuredClone(SYNC_DATA);
+            delete MODIFIED_SYNC_DATA["presence"];
+            const MODIFIED_NEXT_SYNC_DATA: any = structuredClone(NEXT_SYNC_DATA);
+            MODIFIED_NEXT_SYNC_DATA.presence = {
+                events: [
+                    utils.mkPresence({
+                        user: "@foo:bar",
+                        name: "Foo Bar",
+                        presence: "online",
+                    }),
+                ],
+            };
+            httpBackend!.when("GET", "/sync").respond(200, MODIFIED_SYNC_DATA);
+            httpBackend!.when("GET", "/sync").respond(200, MODIFIED_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(MODIFIED_NEXT_SYNC_DATA.presence.events[0]);
+                expect(user.presence).toEqual(MODIFIED_NEXT_SYNC_DATA.presence.events[0]?.content?.presence);
+            });
+            client!.startClient();
+            await httpBackend!.flushAllExpected();
+            expect(fired).toBe(true);
+        });
+
+        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(KnownMembership.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(KnownMembership.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-event-timeline.spec.js

@@ -1,751 +0,0 @@
-import * as utils from "../test-utils";
-import { EventTimeline } from "../../src/matrix";
-import { logger } from "../../src/logger";
-import { TestClient } from "../TestClient";
-
-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",
-    },
-});
-
-const INITIAL_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,
-                            },
-                        }),
-                    ],
-                },
-            },
-        },
-    },
-};
-
-const EVENTS = [
-    utils.mkMessage({
-        room: roomId, user: userId, msg: "we",
-    }),
-    utils.mkMessage({
-        room: roomId, user: userId, msg: "could",
-    }),
-    utils.mkMessage({
-        room: roomId, user: userId, msg: "be",
-    }),
-    utils.mkMessage({
-        room: roomId, user: userId, msg: "heroes",
-    }),
-];
-
-// start the client, and wait for it to initialise
-function startClient(httpBackend, client) {
-    httpBackend.when("GET", "/pushrules").respond(200, {});
-    httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
-    httpBackend.when("GET", "/sync").respond(200, INITIAL_SYNC_DATA);
-
-    client.startClient();
-
-    // set up a promise which will resolve once the client is initialised
-    const prom = new Promise((resolve) => {
-        client.on("sync", function(state) {
-            logger.log("sync", state);
-            if (state != "SYNCING") {
-                return;
-            }
-            resolve();
-        });
-    });
-
-    return Promise.all([
-        httpBackend.flushAllExpected(),
-        prom,
-    ]);
-}
-
-describe("getEventTimeline support", function() {
-    let httpBackend;
-    let client;
-
-    beforeEach(function() {
-        const testClient = new TestClient(userId, "DEVICE", accessToken);
-        client = testClient.client;
-        httpBackend = testClient.httpBackend;
-    });
-
-    afterEach(function() {
-        if (client) {
-            client.stopClient();
-        }
-        return httpBackend.stop();
-    });
-
-    it("timeline support must be enabled to work", function() {
-        return startClient(httpBackend, client).then(function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-            expect(function() {
-                client.getEventTimeline(timelineSet, "event");
-            }).toThrow();
-        });
-    });
-
-    it("timeline support works when enabled", function() {
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { timelineSupport: true },
-        );
-        client = testClient.client;
-        httpBackend = testClient.httpBackend;
-
-        return startClient(httpBackend, client).then(() => {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-            expect(function() {
-                client.getEventTimeline(timelineSet, "event");
-            }).not.toThrow();
-        });
-    });
-
-    it("scrollback should be able to scroll back to before a gappy /sync",
-      function() {
-        // need a client with timelineSupport disabled to make this work
-
-        let room;
-
-        return startClient(httpBackend, client).then(function() {
-            room = client.getRoom(roomId);
-
-            httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: "s_5_4",
-                rooms: {
-                    join: {
-                        "!foo:bar": {
-                            timeline: {
-                                events: [
-                                    EVENTS[0],
-                                ],
-                                prev_batch: "f_1_1",
-                            },
-                        },
-                    },
-                },
-            });
-
-            httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: "s_5_5",
-                rooms: {
-                    join: {
-                        "!foo:bar": {
-                            timeline: {
-                                events: [
-                                    EVENTS[1],
-                                ],
-                                limited: true,
-                                prev_batch: "f_1_2",
-                            },
-                        },
-                    },
-                },
-            });
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client, 2),
-            ]);
-        }).then(function() {
-            expect(room.timeline.length).toEqual(1);
-            expect(room.timeline[0].event).toEqual(EVENTS[1]);
-
-            httpBackend.when("GET", "/messages").respond(200, {
-                chunk: [EVENTS[0]],
-                start: "pagin_start",
-                end: "pagin_end",
-            });
-            httpBackend.flush("/messages", 1);
-            return client.scrollback(room);
-        }).then(function() {
-            expect(room.timeline.length).toEqual(2);
-            expect(room.timeline[0].event).toEqual(EVENTS[0]);
-            expect(room.timeline[1].event).toEqual(EVENTS[1]);
-            expect(room.oldState.paginationToken).toEqual("pagin_end");
-        });
-    });
-});
-
-describe("MatrixClient event timelines", function() {
-    let client = null;
-    let httpBackend = null;
-
-    beforeEach(function() {
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { timelineSupport: true },
-        );
-        client = testClient.client;
-        httpBackend = testClient.httpBackend;
-
-        return startClient(httpBackend, client);
-    });
-
-    afterEach(function() {
-        httpBackend.verifyNoOutstandingExpectation();
-        client.stopClient();
-    });
-
-    describe("getEventTimeline", function() {
-        it("should create a new timeline for new events", function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/event1%3Abar")
-                .respond(200, function() {
-                    return {
-                        start: "start_token",
-                        events_before: [EVENTS[1], EVENTS[0]],
-                        event: EVENTS[2],
-                        events_after: [EVENTS[3]],
-                        state: [
-                            ROOM_NAME_EVENT,
-                            USER_MEMBERSHIP_EVENT,
-                        ],
-                        end: "end_token",
-                    };
-                });
-
-            return Promise.all([
-                client.getEventTimeline(timelineSet, "event1:bar").then(function(tl) {
-                    expect(tl.getEvents().length).toEqual(4);
-                    for (let i = 0; i < 4; i++) {
-                        expect(tl.getEvents()[i].event).toEqual(EVENTS[i]);
-                        expect(tl.getEvents()[i].sender.name).toEqual(userName);
-                    }
-                    expect(tl.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toEqual("start_token");
-                    expect(tl.getPaginationToken(EventTimeline.FORWARDS))
-                        .toEqual("end_token");
-                }),
-                httpBackend.flushAllExpected(),
-            ]);
-        });
-
-        it("should return existing timeline for known events", function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-            httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: "s_5_4",
-                rooms: {
-                    join: {
-                        "!foo:bar": {
-                            timeline: {
-                                events: [
-                                    EVENTS[0],
-                                ],
-                                prev_batch: "f_1_2",
-                            },
-                        },
-                    },
-                },
-            });
-
-            return Promise.all([
-                httpBackend.flush("/sync"),
-                utils.syncPromise(client),
-            ]).then(function() {
-                return client.getEventTimeline(timelineSet, EVENTS[0].event_id);
-            }).then(function(tl) {
-                expect(tl.getEvents().length).toEqual(2);
-                expect(tl.getEvents()[1].event).toEqual(EVENTS[0]);
-                expect(tl.getEvents()[1].sender.name).toEqual(userName);
-                expect(tl.getPaginationToken(EventTimeline.BACKWARDS))
-                    .toEqual("f_1_1");
-                // expect(tl.getPaginationToken(EventTimeline.FORWARDS))
-                //    .toEqual("s_5_4");
-            });
-        });
-
-        it("should update timelines where they overlap a previous /sync", function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-            httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: "s_5_4",
-                rooms: {
-                    join: {
-                        "!foo:bar": {
-                            timeline: {
-                                events: [
-                                    EVENTS[3],
-                                ],
-                                prev_batch: "f_1_2",
-                            },
-                        },
-                    },
-                },
-            });
-
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[2].event_id))
-                .respond(200, function() {
-                    return {
-                        start: "start_token",
-                        events_before: [EVENTS[1]],
-                        event: EVENTS[2],
-                        events_after: [EVENTS[3]],
-                        end: "end_token",
-                        state: [],
-                    };
-                });
-
-            const prom = new Promise((resolve, reject) => {
-                client.on("sync", function() {
-                    client.getEventTimeline(timelineSet, EVENTS[2].event_id,
-                    ).then(function(tl) {
-                        expect(tl.getEvents().length).toEqual(4);
-                        expect(tl.getEvents()[0].event).toEqual(EVENTS[1]);
-                        expect(tl.getEvents()[1].event).toEqual(EVENTS[2]);
-                        expect(tl.getEvents()[3].event).toEqual(EVENTS[3]);
-                        expect(tl.getPaginationToken(EventTimeline.BACKWARDS))
-                            .toEqual("start_token");
-                        // expect(tl.getPaginationToken(EventTimeline.FORWARDS))
-                        //    .toEqual("s_5_4");
-                    }).then(resolve, reject);
-                });
-            });
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                prom,
-            ]);
-        });
-
-        it("should join timelines where they overlap a previous /context",
-          function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-
-            // we fetch event 0, then 2, then 3, and finally 1. 1 is returned
-            // with context which joins them all up.
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[0].event_id))
-                .respond(200, function() {
-                    return {
-                        start: "start_token0",
-                        events_before: [],
-                        event: EVENTS[0],
-                        events_after: [],
-                        end: "end_token0",
-                        state: [],
-                    };
-                });
-
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[2].event_id))
-                .respond(200, function() {
-                    return {
-                        start: "start_token2",
-                        events_before: [],
-                        event: EVENTS[2],
-                        events_after: [],
-                        end: "end_token2",
-                        state: [],
-                    };
-                });
-
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[3].event_id))
-                .respond(200, function() {
-                    return {
-                        start: "start_token3",
-                        events_before: [],
-                        event: EVENTS[3],
-                        events_after: [],
-                        end: "end_token3",
-                        state: [],
-                    };
-                });
-
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[1].event_id))
-                .respond(200, function() {
-                    return {
-                        start: "start_token4",
-                        events_before: [EVENTS[0]],
-                        event: EVENTS[1],
-                        events_after: [EVENTS[2], EVENTS[3]],
-                        end: "end_token4",
-                        state: [],
-                    };
-                });
-
-            let tl0;
-            let tl3;
-            return Promise.all([
-                client.getEventTimeline(timelineSet, EVENTS[0].event_id,
-                ).then(function(tl) {
-                    expect(tl.getEvents().length).toEqual(1);
-                    tl0 = tl;
-                    return client.getEventTimeline(timelineSet, EVENTS[2].event_id);
-                }).then(function(tl) {
-                    expect(tl.getEvents().length).toEqual(1);
-                    return client.getEventTimeline(timelineSet, EVENTS[3].event_id);
-                }).then(function(tl) {
-                    expect(tl.getEvents().length).toEqual(1);
-                    tl3 = tl;
-                    return client.getEventTimeline(timelineSet, EVENTS[1].event_id);
-                }).then(function(tl) {
-                    // we expect it to get merged in with event 2
-                    expect(tl.getEvents().length).toEqual(2);
-                    expect(tl.getEvents()[0].event).toEqual(EVENTS[1]);
-                    expect(tl.getEvents()[1].event).toEqual(EVENTS[2]);
-                    expect(tl.getNeighbouringTimeline(EventTimeline.BACKWARDS))
-                        .toBe(tl0);
-                    expect(tl.getNeighbouringTimeline(EventTimeline.FORWARDS))
-                        .toBe(tl3);
-                    expect(tl0.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toEqual("start_token0");
-                    expect(tl0.getPaginationToken(EventTimeline.FORWARDS))
-                        .toBe(null);
-                    expect(tl3.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toBe(null);
-                    expect(tl3.getPaginationToken(EventTimeline.FORWARDS))
-                        .toEqual("end_token3");
-                }),
-                httpBackend.flushAllExpected(),
-            ]);
-        });
-
-        it("should fail gracefully if there is no event field", function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-            // we fetch event 0, then 2, then 3, and finally 1. 1 is returned
-            // with context which joins them all up.
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/event1")
-                .respond(200, function() {
-                    return {
-                        start: "start_token",
-                        events_before: [],
-                        events_after: [],
-                        end: "end_token",
-                        state: [],
-                    };
-                });
-
-            return Promise.all([
-                client.getEventTimeline(timelineSet, "event1",
-                ).then(function(tl) {
-                    // could do with a fail()
-                    expect(true).toBeFalsy();
-                }, function(e) {
-                    expect(String(e)).toMatch(/'event'/);
-                }),
-                httpBackend.flushAllExpected(),
-            ]);
-        });
-    });
-
-    describe("paginateEventTimeline", function() {
-        it("should allow you to paginate backwards", function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[0].event_id))
-                .respond(200, function() {
-                    return {
-                        start: "start_token0",
-                        events_before: [],
-                        event: EVENTS[0],
-                        events_after: [],
-                        end: "end_token0",
-                        state: [],
-                    };
-                });
-
-            httpBackend.when("GET", "/rooms/!foo%3Abar/messages")
-                .check(function(req) {
-                    const params = req.queryParams;
-                    expect(params.dir).toEqual("b");
-                    expect(params.from).toEqual("start_token0");
-                    expect(params.limit).toEqual(30);
-                }).respond(200, function() {
-                    return {
-                        chunk: [EVENTS[1], EVENTS[2]],
-                        end: "start_token1",
-                    };
-                });
-
-            let tl;
-            return Promise.all([
-                client.getEventTimeline(timelineSet, EVENTS[0].event_id,
-                ).then(function(tl0) {
-                    tl = tl0;
-                    return client.paginateEventTimeline(tl, { backwards: true });
-                }).then(function(success) {
-                    expect(success).toBeTruthy();
-                    expect(tl.getEvents().length).toEqual(3);
-                    expect(tl.getEvents()[0].event).toEqual(EVENTS[2]);
-                    expect(tl.getEvents()[1].event).toEqual(EVENTS[1]);
-                    expect(tl.getEvents()[2].event).toEqual(EVENTS[0]);
-                    expect(tl.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toEqual("start_token1");
-                    expect(tl.getPaginationToken(EventTimeline.FORWARDS))
-                        .toEqual("end_token0");
-                }),
-                httpBackend.flushAllExpected(),
-            ]);
-        });
-
-        it("should allow you to paginate forwards", function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[0].event_id))
-                .respond(200, function() {
-                    return {
-                        start: "start_token0",
-                        events_before: [],
-                        event: EVENTS[0],
-                        events_after: [],
-                        end: "end_token0",
-                        state: [],
-                    };
-                });
-
-            httpBackend.when("GET", "/rooms/!foo%3Abar/messages")
-                .check(function(req) {
-                    const params = req.queryParams;
-                    expect(params.dir).toEqual("f");
-                    expect(params.from).toEqual("end_token0");
-                    expect(params.limit).toEqual(20);
-                }).respond(200, function() {
-                    return {
-                        chunk: [EVENTS[1], EVENTS[2]],
-                        end: "end_token1",
-                    };
-                });
-
-            let tl;
-            return Promise.all([
-                client.getEventTimeline(timelineSet, EVENTS[0].event_id,
-                ).then(function(tl0) {
-                    tl = tl0;
-                    return client.paginateEventTimeline(
-                        tl, { backwards: false, limit: 20 });
-                }).then(function(success) {
-                    expect(success).toBeTruthy();
-                    expect(tl.getEvents().length).toEqual(3);
-                    expect(tl.getEvents()[0].event).toEqual(EVENTS[0]);
-                    expect(tl.getEvents()[1].event).toEqual(EVENTS[1]);
-                    expect(tl.getEvents()[2].event).toEqual(EVENTS[2]);
-                    expect(tl.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toEqual("start_token0");
-                    expect(tl.getPaginationToken(EventTimeline.FORWARDS))
-                        .toEqual("end_token1");
-                }),
-                httpBackend.flushAllExpected(),
-            ]);
-        });
-    });
-
-    describe("event timeline for sent events", function() {
-        const TXN_ID = "txn1";
-        const event = utils.mkMessage({
-            room: roomId, user: userId, msg: "a body",
-        });
-        event.unsigned = { transaction_id: TXN_ID };
-
-        beforeEach(function() {
-            // set up handlers for both the message send, and the
-            // /sync
-            httpBackend.when("PUT", "/send/m.room.message/" + TXN_ID)
-                .respond(200, {
-                    event_id: event.event_id,
-                });
-            httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: "s_5_4",
-                rooms: {
-                    join: {
-                        "!foo:bar": {
-                            timeline: {
-                                events: [
-                                    event,
-                                ],
-                                prev_batch: "f_1_1",
-                            },
-                        },
-                    },
-                },
-            });
-        });
-
-        it("should work when /send returns before /sync", function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-
-            return Promise.all([
-                client.sendTextMessage(roomId, "a body", TXN_ID).then(function(res) {
-                    expect(res.event_id).toEqual(event.event_id);
-                    return client.getEventTimeline(timelineSet, event.event_id);
-                }).then(function(tl) {
-                    // 2 because the initial sync contained an event
-                    expect(tl.getEvents().length).toEqual(2);
-                    expect(tl.getEvents()[1].getContent().body).toEqual("a body");
-
-                    // now let the sync complete, and check it again
-                    return Promise.all([
-                        httpBackend.flush("/sync", 1),
-                        utils.syncPromise(client),
-                    ]);
-                }).then(function() {
-                    return client.getEventTimeline(timelineSet, event.event_id);
-                }).then(function(tl) {
-                    expect(tl.getEvents().length).toEqual(2);
-                    expect(tl.getEvents()[1].event).toEqual(event);
-                }),
-
-                httpBackend.flush("/send/m.room.message/" + TXN_ID, 1),
-            ]);
-        });
-
-        it("should work when /send returns after /sync", function() {
-            const room = client.getRoom(roomId);
-            const timelineSet = room.getTimelineSets()[0];
-
-            return Promise.all([
-                // initiate the send, and set up checks to be done when it completes
-                // - but note that it won't complete until after the /sync does, below.
-                client.sendTextMessage(roomId, "a body", TXN_ID).then(function(res) {
-                    logger.log("sendTextMessage completed");
-                    expect(res.event_id).toEqual(event.event_id);
-                    return client.getEventTimeline(timelineSet, event.event_id);
-                }).then(function(tl) {
-                    logger.log("getEventTimeline completed (2)");
-                    expect(tl.getEvents().length).toEqual(2);
-                    expect(tl.getEvents()[1].getContent().body).toEqual("a body");
-                }),
-
-                Promise.all([
-                    httpBackend.flush("/sync", 1),
-                    utils.syncPromise(client),
-                ]).then(function() {
-                    return client.getEventTimeline(timelineSet, event.event_id);
-                }).then(function(tl) {
-                    logger.log("getEventTimeline completed (1)");
-                    expect(tl.getEvents().length).toEqual(2);
-                    expect(tl.getEvents()[1].event).toEqual(event);
-
-                    // now let the send complete.
-                    return httpBackend.flush("/send/m.room.message/" + TXN_ID, 1);
-                }),
-            ]);
-        });
-    });
-
-    it("should handle gappy syncs after redactions", function() {
-        // https://github.com/vector-im/vector-web/issues/1389
-
-        // a state event, followed by a redaction thereof
-        const event = utils.mkMembership({
-            room: roomId, mship: "join", user: otherUserId,
-        });
-        const redaction = utils.mkEvent({
-            type: "m.room.redaction",
-            room_id: roomId,
-            sender: otherUserId,
-            content: {},
-        });
-        redaction.redacts = event.event_id;
-
-        const syncData = {
-            next_batch: "batch1",
-            rooms: {
-                join: {},
-            },
-        };
-        syncData.rooms.join[roomId] = {
-            timeline: {
-                events: [
-                    event,
-                    redaction,
-                ],
-                limited: false,
-            },
-        };
-        httpBackend.when("GET", "/sync").respond(200, syncData);
-
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            utils.syncPromise(client),
-        ]).then(function() {
-            const room = client.getRoom(roomId);
-            const tl = room.getLiveTimeline();
-            expect(tl.getEvents().length).toEqual(3);
-            expect(tl.getEvents()[1].isRedacted()).toBe(true);
-
-            const sync2 = {
-                next_batch: "batch2",
-                rooms: {
-                    join: {},
-                },
-            };
-            sync2.rooms.join[roomId] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomId, user: otherUserId, msg: "world",
-                        }),
-                    ],
-                    limited: true,
-                    prev_batch: "newerTok",
-                },
-            };
-            httpBackend.when("GET", "/sync").respond(200, sync2);
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client),
-            ]);
-        }).then(function() {
-            const room = client.getRoom(roomId);
-            const tl = room.getLiveTimeline();
-            expect(tl.getEvents().length).toEqual(1);
-        });
-    });
-});

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

@@ -1,403 +0,0 @@
-import * as utils from "../test-utils";
-import { CRYPTO_ENABLED } from "../../src/client";
-import { Filter, MemoryStore, Room } from "../../src/matrix";
-import { TestClient } from "../TestClient";
-
-describe("MatrixClient", function() {
-    let client = null;
-    let httpBackend = null;
-    let store = null;
-    const userId = "@alice:localhost";
-    const accessToken = "aseukfgwef";
-
-    beforeEach(function() {
-        store = new MemoryStore();
-
-        const testClient = new TestClient(userId, "aliceDevice", accessToken, undefined, {
-            store: store,
-        });
-        httpBackend = testClient.httpBackend;
-        client = testClient.client;
-    });
-
-    afterEach(function() {
-        httpBackend.verifyNoOutstandingExpectation();
-        return httpBackend.stop();
-    });
-
-    describe("uploadContent", function() {
-        const buf = new Buffer('hello world');
-        it("should upload the file", function() {
-            httpBackend.when(
-                "POST", "/_matrix/media/r0/upload",
-            ).check(function(req) {
-                expect(req.rawData).toEqual(buf);
-                expect(req.queryParams.filename).toEqual("hi.txt");
-                if (!(req.queryParams.access_token == accessToken ||
-                        req.headers["Authorization"] == "Bearer " + accessToken)) {
-                    expect(true).toBe(false);
-                }
-                expect(req.headers["Content-Type"]).toEqual("text/plain");
-                expect(req.opts.json).toBeFalsy();
-                expect(req.opts.timeout).toBe(undefined);
-            }).respond(200, "content", true);
-
-            const prom = client.uploadContent({
-                stream: buf,
-                name: "hi.txt",
-                type: "text/plain",
-            });
-
-            expect(prom).toBeTruthy();
-
-            const uploads = client.getCurrentUploads();
-            expect(uploads.length).toEqual(1);
-            expect(uploads[0].promise).toBe(prom);
-            expect(uploads[0].loaded).toEqual(0);
-
-            const prom2 = prom.then(function(response) {
-                // for backwards compatibility, we return the raw JSON
-                expect(response).toEqual("content");
-
-                const uploads = client.getCurrentUploads();
-                expect(uploads.length).toEqual(0);
-            });
-
-            httpBackend.flush();
-            return prom2;
-        });
-
-        it("should parse the response if rawResponse=false", function() {
-            httpBackend.when(
-                "POST", "/_matrix/media/r0/upload",
-            ).check(function(req) {
-                expect(req.opts.json).toBeFalsy();
-            }).respond(200, { "content_uri": "uri" });
-
-            const prom = client.uploadContent({
-                stream: buf,
-                name: "hi.txt",
-                type: "text/plain",
-            }, {
-                rawResponse: false,
-            }).then(function(response) {
-                expect(response.content_uri).toEqual("uri");
-            });
-
-            httpBackend.flush();
-            return prom;
-        });
-
-        it("should parse errors into a MatrixError", function() {
-            httpBackend.when(
-                "POST", "/_matrix/media/r0/upload",
-            ).check(function(req) {
-                expect(req.rawData).toEqual(buf);
-                expect(req.opts.json).toBeFalsy();
-            }).respond(400, {
-                "errcode": "M_SNAFU",
-                "error": "broken",
-            });
-
-            const prom = client.uploadContent({
-                stream: buf,
-                name: "hi.txt",
-                type: "text/plain",
-            }).then(function(response) {
-                throw Error("request not failed");
-            }, function(error) {
-                expect(error.httpStatus).toEqual(400);
-                expect(error.errcode).toEqual("M_SNAFU");
-                expect(error.message).toEqual("broken");
-            });
-
-            httpBackend.flush();
-            return prom;
-        });
-
-        it("should return a promise which can be cancelled", function() {
-            const prom = client.uploadContent({
-                stream: buf,
-                name: "hi.txt",
-                type: "text/plain",
-            });
-
-            const uploads = client.getCurrentUploads();
-            expect(uploads.length).toEqual(1);
-            expect(uploads[0].promise).toBe(prom);
-            expect(uploads[0].loaded).toEqual(0);
-
-            const prom2 = prom.then(function(response) {
-                throw Error("request not aborted");
-            }, function(error) {
-                expect(error).toEqual("aborted");
-
-                const uploads = client.getCurrentUploads();
-                expect(uploads.length).toEqual(0);
-            });
-
-            const r = client.cancelUpload(prom);
-            expect(r).toBe(true);
-            return prom2;
-        });
-    });
-
-    describe("joinRoom", function() {
-        it("should no-op if you've already joined a room", function() {
-            const roomId = "!foo:bar";
-            const room = new Room(roomId, userId);
-            room.addLiveEvents([
-                utils.mkMembership({
-                    user: userId, room: roomId, mship: "join", event: true,
-                }),
-            ]);
-            store.storeRoom(room);
-            client.joinRoom(roomId);
-            httpBackend.verifyNoOutstandingRequests();
-        });
-    });
-
-    describe("getFilter", function() {
-        const filterId = "f1lt3r1d";
-
-        it("should return a filter from the store if allowCached", function(done) {
-            const filter = Filter.fromJson(userId, filterId, {
-                event_format: "client",
-            });
-            store.storeFilter(filter);
-            client.getFilter(userId, filterId, true).then(function(gotFilter) {
-                expect(gotFilter).toEqual(filter);
-                done();
-            });
-            httpBackend.verifyNoOutstandingRequests();
-        });
-
-        it("should do an HTTP request if !allowCached even if one exists",
-        function(done) {
-            const httpFilterDefinition = {
-                event_format: "federation",
-            };
-
-            httpBackend.when(
-                "GET", "/user/" + encodeURIComponent(userId) + "/filter/" + filterId,
-            ).respond(200, httpFilterDefinition);
-
-            const storeFilter = Filter.fromJson(userId, filterId, {
-                event_format: "client",
-            });
-            store.storeFilter(storeFilter);
-            client.getFilter(userId, filterId, false).then(function(gotFilter) {
-                expect(gotFilter.getDefinition()).toEqual(httpFilterDefinition);
-                done();
-            });
-
-            httpBackend.flush();
-        });
-
-        it("should do an HTTP request if nothing is in the cache and then store it",
-        function(done) {
-            const httpFilterDefinition = {
-                event_format: "federation",
-            };
-            expect(store.getFilter(userId, filterId)).toBe(null);
-
-            httpBackend.when(
-                "GET", "/user/" + encodeURIComponent(userId) + "/filter/" + filterId,
-            ).respond(200, httpFilterDefinition);
-            client.getFilter(userId, filterId, true).then(function(gotFilter) {
-                expect(gotFilter.getDefinition()).toEqual(httpFilterDefinition);
-                expect(store.getFilter(userId, filterId)).toBeTruthy();
-                done();
-            });
-
-            httpBackend.flush();
-        });
-    });
-
-    describe("createFilter", function() {
-        const filterId = "f1llllllerid";
-
-        it("should do an HTTP request and then store the filter", function(done) {
-            expect(store.getFilter(userId, filterId)).toBe(null);
-
-            const filterDefinition = {
-                event_format: "client",
-            };
-
-            httpBackend.when(
-                "POST", "/user/" + encodeURIComponent(userId) + "/filter",
-            ).check(function(req) {
-                expect(req.data).toEqual(filterDefinition);
-            }).respond(200, {
-                filter_id: filterId,
-            });
-
-            client.createFilter(filterDefinition).then(function(gotFilter) {
-                expect(gotFilter.getDefinition()).toEqual(filterDefinition);
-                expect(store.getFilter(userId, filterId)).toEqual(gotFilter);
-                done();
-            });
-
-            httpBackend.flush();
-        });
-    });
-
-    describe("searching", function() {
-        const response = {
-            search_categories: {
-                room_events: {
-                    count: 24,
-                    results: {
-                        "$flibble:localhost": {
-                            rank: 0.1,
-                            result: {
-                                type: "m.room.message",
-                                user_id: "@alice:localhost",
-                                room_id: "!feuiwhf:localhost",
-                                content: {
-                                    body: "a result",
-                                    msgtype: "m.text",
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-
-        it("searchMessageText should perform a /search for room_events", function(done) {
-            client.searchMessageText({
-                query: "monkeys",
-            });
-            httpBackend.when("POST", "/search").check(function(req) {
-                expect(req.data).toEqual({
-                    search_categories: {
-                        room_events: {
-                            search_term: "monkeys",
-                        },
-                    },
-                });
-            }).respond(200, response);
-
-            httpBackend.flush().then(function() {
-                done();
-            });
-        });
-    });
-
-    describe("downloadKeys", function() {
-        if (!CRYPTO_ENABLED) {
-            return;
-        }
-
-        beforeEach(function() {
-            return client.initCrypto();
-        });
-
-        it("should do an HTTP request and then store the keys", function() {
-            const ed25519key = "7wG2lzAqbjcyEkOP7O4gU7ItYcn+chKzh5sT/5r2l78";
-            // ed25519key = client.getDeviceEd25519Key();
-            const borisKeys = {
-                dev1: {
-                    algorithms: ["1"],
-                    device_id: "dev1",
-                    keys: { "ed25519:dev1": ed25519key },
-                    signatures: {
-                        boris: {
-                            "ed25519:dev1":
-                                "RAhmbNDq1efK3hCpBzZDsKoGSsrHUxb25NW5/WbEV9R" +
-                                "JVwLdP032mg5QsKt/pBDUGtggBcnk43n3nBWlA88WAw",
-                        },
-                    },
-                    unsigned: { "abc": "def" },
-                    user_id: "boris",
-                },
-            };
-            const chazKeys = {
-                dev2: {
-                    algorithms: ["2"],
-                    device_id: "dev2",
-                    keys: { "ed25519:dev2": ed25519key },
-                    signatures: {
-                        chaz: {
-                           "ed25519:dev2":
-                                "FwslH/Q7EYSb7swDJbNB5PSzcbEO1xRRBF1riuijqvL" +
-                                "EkrK9/XVN8jl4h7thGuRITQ01siBQnNmMK9t45QfcCQ",
-                        },
-                    },
-                    unsigned: { "ghi": "def" },
-                    user_id: "chaz",
-                },
-            };
-
-            /*
-            function sign(o) {
-                var anotherjson = require('another-json');
-                var b = JSON.parse(JSON.stringify(o));
-                delete(b.signatures);
-                delete(b.unsigned);
-                return client.crypto.olmDevice.sign(anotherjson.stringify(b));
-            };
-
-            logger.log("Ed25519: " + ed25519key);
-            logger.log("boris:", sign(borisKeys.dev1));
-            logger.log("chaz:", sign(chazKeys.dev2));
-            */
-
-            httpBackend.when("POST", "/keys/query").check(function(req) {
-                expect(req.data).toEqual({ device_keys: {
-                    'boris': [],
-                    'chaz': [],
-                } });
-            }).respond(200, {
-                device_keys: {
-                    boris: borisKeys,
-                    chaz: chazKeys,
-                },
-            });
-
-            const prom = client.downloadKeys(["boris", "chaz"]).then(function(res) {
-                assertObjectContains(res.boris.dev1, {
-                    verified: 0, // DeviceVerification.UNVERIFIED
-                    keys: { "ed25519:dev1": ed25519key },
-                    algorithms: ["1"],
-                    unsigned: { "abc": "def" },
-                });
-
-                assertObjectContains(res.chaz.dev2, {
-                    verified: 0, // DeviceVerification.UNVERIFIED
-                    keys: { "ed25519:dev2": ed25519key },
-                    algorithms: ["2"],
-                    unsigned: { "ghi": "def" },
-                });
-            });
-
-            httpBackend.flush();
-            return prom;
-        });
-    });
-
-    describe("deleteDevice", function() {
-        const auth = { a: 1 };
-        it("should pass through an auth dict", function() {
-            httpBackend.when(
-                "DELETE", "/_matrix/client/r0/devices/my_device",
-            ).check(function(req) {
-                expect(req.data).toEqual({ auth: auth });
-            }).respond(200);
-
-            const prom = client.deleteDevice("my_device", auth);
-
-            httpBackend.flush();
-            return prom;
-        });
-    });
-});
-
-function assertObjectContains(obj, expected) {
-    for (const k in expected) {
-        if (expected.hasOwnProperty(k)) {
-            expect(obj[k]).toEqual(expected[k]);
-        }
-    }
-}

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

@@ -1,184 +0,0 @@
-import * as utils from "../test-utils";
-import HttpBackend from "matrix-mock-request";
-import { MatrixClient } from "../../src/matrix";
-import { MatrixScheduler } from "../../src/scheduler";
-import { MemoryStore } from "../../src/store/memory";
-import { MatrixError } from "../../src/http-api";
-
-describe("MatrixClient opts", function() {
-    const baseUrl = "http://localhost.or.something";
-    let client = null;
-    let httpBackend = null;
-    const userId = "@alice:localhost";
-    const userB = "@bob:localhost";
-    const accessToken = "aseukfgwef";
-    const roomId = "!foo:bar";
-    const syncData = {
-        next_batch: "s_5_3",
-        presence: {},
-        rooms: {
-            join: {
-                "!foo:bar": { // roomId
-                    timeline: {
-                        events: [
-                            utils.mkMessage({
-                                room: roomId, user: userB, msg: "hello",
-                            }),
-                        ],
-                        prev_batch: "f_1_1",
-                    },
-                    state: {
-                        events: [
-                            utils.mkEvent({
-                                type: "m.room.name", room: roomId, user: userB,
-                                content: {
-                                    name: "Old room name",
-                                },
-                            }),
-                            utils.mkMembership({
-                                room: roomId, mship: "join", user: userB, name: "Bob",
-                            }),
-                            utils.mkMembership({
-                                room: roomId, mship: "join", user: userId, name: "Alice",
-                            }),
-                            utils.mkEvent({
-                                type: "m.room.create", room: roomId, user: userId,
-                                content: {
-                                    creator: userId,
-                                },
-                            }),
-                        ],
-                    },
-                },
-            },
-        },
-    };
-
-    beforeEach(function() {
-        httpBackend = new HttpBackend();
-    });
-
-    afterEach(function() {
-        httpBackend.verifyNoOutstandingExpectation();
-        return httpBackend.stop();
-    });
-
-    describe("without opts.store", function() {
-        beforeEach(function() {
-            client = new MatrixClient({
-                request: httpBackend.requestFn,
-                store: undefined,
-                baseUrl: baseUrl,
-                userId: userId,
-                accessToken: accessToken,
-                scheduler: new MatrixScheduler(),
-            });
-        });
-
-        afterEach(function() {
-            client.stopClient();
-        });
-
-        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) {
-                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",
-                "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,
-                );
-            });
-            httpBackend.when("GET", "/pushrules").respond(200, {});
-            httpBackend.when("POST", "/filter").respond(200, { filter_id: "foo" });
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-            await client.startClient();
-            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,
-            );
-        });
-    });
-
-    describe("without opts.scheduler", function() {
-        beforeEach(function() {
-            client = new MatrixClient({
-                request: httpBackend.requestFn,
-                store: new MemoryStore(),
-                baseUrl: baseUrl,
-                userId: userId,
-                accessToken: accessToken,
-                scheduler: undefined,
-            });
-        });
-
-        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();
-            });
-            httpBackend.flush("/txn1", 1);
-        });
-
-        it("shouldn't queue events", function(done) {
-            httpBackend.when("PUT", "/txn1").respond(200, {
-                event_id: "AAA",
-            });
-            httpBackend.when("PUT", "/txn2").respond(200, {
-                event_id: "BBB",
-            });
-            let sentA = false;
-            let sentB = false;
-            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) {
-                sentB = true;
-                expect(sentA).toBe(false);
-            });
-            httpBackend.flush("/txn2", 1).then(function() {
-                httpBackend.flush("/txn1", 1).then(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) {
-                expect(res.event_id).toEqual("foo");
-                done();
-            });
-            httpBackend.flush("/txn1", 1);
-        });
-    });
-});

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

@@ -0,0 +1,208 @@
+import HttpBackend from "matrix-mock-request";
+
+import * as utils from "../test-utils/test-utils";
+import { ClientEvent, MatrixClient } from "../../src/matrix";
+import { MatrixScheduler } from "../../src/scheduler";
+import { MemoryStore } from "../../src/store/memory";
+import { MatrixError } from "../../src/http-api";
+import { IStore } from "../../src/store";
+import { KnownMembership } from "../../src/@types/membership";
+
+describe("MatrixClient opts", function () {
+    const baseUrl = "http://localhost.or.something";
+    let httpBackend = new HttpBackend();
+    const userId = "@alice:localhost";
+    const userB = "@bob:localhost";
+    const accessToken = "aseukfgwef";
+    const roomId = "!foo:bar";
+    const syncData = {
+        next_batch: "s_5_3",
+        presence: {},
+        rooms: {
+            join: {
+                "!foo:bar": {
+                    // roomId
+                    timeline: {
+                        events: [
+                            utils.mkMessage({
+                                room: roomId,
+                                user: userB,
+                                msg: "hello",
+                            }),
+                        ],
+                        prev_batch: "f_1_1",
+                    },
+                    state: {
+                        events: [
+                            utils.mkEvent({
+                                type: "m.room.name",
+                                room: roomId,
+                                user: userB,
+                                content: {
+                                    name: "Old room name",
+                                },
+                            }),
+                            utils.mkMembership({
+                                room: roomId,
+                                mship: KnownMembership.Join,
+                                user: userB,
+                                name: "Bob",
+                            }),
+                            utils.mkMembership({
+                                room: roomId,
+                                mship: KnownMembership.Join,
+                                user: userId,
+                                name: "Alice",
+                            }),
+                            utils.mkEvent({
+                                type: "m.room.create",
+                                room: roomId,
+                                user: userId,
+                                content: {},
+                            }),
+                        ],
+                    },
+                },
+            },
+        },
+    };
+
+    beforeEach(function () {
+        httpBackend = new HttpBackend();
+    });
+
+    afterEach(function () {
+        httpBackend.verifyNoOutstandingExpectation();
+        return httpBackend.stop();
+    });
+
+    describe("without opts.store", function () {
+        let client: MatrixClient;
+        beforeEach(function () {
+            client = new MatrixClient({
+                fetchFn: httpBackend.fetchFn as typeof global.fetch,
+                store: undefined,
+                baseUrl: baseUrl,
+                userId: userId,
+                accessToken: accessToken,
+                scheduler: new MatrixScheduler(),
+            });
+        });
+
+        afterEach(function () {
+            client.stopClient();
+        });
+
+        it("should be able to send messages", async () => {
+            const eventId = "$flibble:wibble";
+            httpBackend.when("PUT", "/txn1").respond(200, {
+                event_id: eventId,
+            });
+            const [res] = await Promise.all([
+                client.sendTextMessage("!foo:bar", "a body", "txn1"),
+                httpBackend.flush("/txn1", 1),
+            ]);
+            expect(res.event_id).toEqual(eventId);
+        });
+
+        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(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, {});
+            httpBackend.when("POST", "/filter").respond(200, { filter_id: "foo" });
+            httpBackend.when("GET", "/sync").respond(200, syncData);
+            client.startClient();
+            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);
+        });
+    });
+
+    describe("without opts.scheduler", function () {
+        let client: MatrixClient;
+        beforeEach(function () {
+            client = new MatrixClient({
+                fetchFn: httpBackend.fetchFn as typeof global.fetch,
+                store: new MemoryStore() as IStore,
+                baseUrl: baseUrl,
+                userId: userId,
+                accessToken: accessToken,
+                scheduler: undefined,
+            });
+        });
+
+        afterEach(function () {
+            client.stopClient();
+        });
+
+        it("shouldn't retry sending events", async () => {
+            httpBackend.when("PUT", "/txn1").respond(
+                500,
+                new MatrixError({
+                    errcode: "M_SOMETHING",
+                    error: "Ruh roh",
+                }),
+            );
+
+            await expect(
+                Promise.all([client.sendTextMessage("!foo:bar", "a body", "txn1"), httpBackend.flush("/txn1", 1)]),
+            ).rejects.toThrow("MatrixError: [500] Unknown message");
+        });
+
+        it("shouldn't queue events", async () => {
+            httpBackend.when("PUT", "/txn1").respond(200, {
+                event_id: "AAA",
+            });
+            httpBackend.when("PUT", "/txn2").respond(200, {
+                event_id: "BBB",
+            });
+            let sentA = false;
+            let sentB = false;
+            const messageASendPromise = client.sendTextMessage("!foo:bar", "a body", "txn1").then(function (res) {
+                sentA = true;
+                // We expect messageB to be sent before messageA to ensure as we're
+                // testing that there is no queueing that blocks each other
+                expect(sentB).toBe(true);
+            });
+            const messageBSendPromise = client.sendTextMessage("!foo:bar", "b body", "txn2").then(function (res) {
+                sentB = true;
+                // We expect messageB to be sent before messageA to ensure as we're
+                // testing that there is no queueing that blocks each other
+                expect(sentA).toBe(false);
+            });
+            // Allow messageB to succeed first
+            await httpBackend.flush("/txn2", 1);
+            // Then allow messageA to succeed
+            await httpBackend.flush("/txn1", 1);
+
+            // Now await the message send promises to
+            await messageBSendPromise;
+            await messageASendPromise;
+        });
+
+        it("should be able to send messages", async () => {
+            httpBackend.when("PUT", "/txn1").respond(200, {
+                event_id: "foo",
+            });
+            const [res] = await Promise.all([
+                client.sendTextMessage("!foo:bar", "a body", "txn1"),
+                httpBackend.flush("/txn1", 1),
+            ]);
+
+            expect(res.event_id).toEqual("foo");
+        });
+    });
+});

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.js

@@ -1,122 +0,0 @@
-import { EventStatus } from "../../src/matrix";
-import { MatrixScheduler } from "../../src/scheduler";
-import { Room } from "../../src/models/room";
-import { TestClient } from "../TestClient";
-
-describe("MatrixClient retrying", function() {
-    let client = null;
-    let httpBackend = null;
-    let scheduler;
-    const userId = "@alice:localhost";
-    const accessToken = "aseukfgwef";
-    const roomId = "!room:here";
-    let room;
-
-    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.store.storeRoom(room);
-    });
-
-    afterEach(function() {
-        httpBackend.verifyNoOutstandingExpectation();
-        return httpBackend.stop();
-    });
-
-    xit("should retry according to MatrixScheduler.retryFn", 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() {
-
-    });
-
-    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, "m1").then(function(ev) {
-            // we expect the first message to fail
-            throw new Error('Message 1 unexpectedly sent successfully');
-        }, (e) => {
-            // 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, "m2");
-
-        // both events should be in the timeline at this point
-        const tl = room.getLiveTimeline().getEvents();
-        expect(tl.length).toEqual(2);
-        const ev1 = tl[0];
-        const ev2 = tl[1];
-
-        expect(ev1.status).toEqual(EventStatus.SENDING);
-        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(rq) {
-            // 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);
-
-            // 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((resolve, reject) => {
-            room.on("Room.localEchoUpdated", (ev0) => {
-                if (ev0 === ev1) {
-                    resolve();
-                }
-            });
-        }).then(function() {
-            expect(ev1.status).toEqual(EventStatus.NOT_SENT);
-            expect(tl.length).toEqual(1);
-
-            // cancel the first message
-            client.cancelPendingEvent(ev1);
-            expect(ev1.status).toEqual(EventStatus.CANCELLED);
-            expect(tl.length).toEqual(0);
-        });
-
-        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() {
-
-        });
-    });
-});

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

@@ -0,0 +1,136 @@
+/*
+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 { EventStatus, MatrixClient, MatrixScheduler, MsgType, RoomEvent } from "../../src/matrix";
+import { Room } from "../../src/models/room";
+import { TestClient } from "../TestClient";
+
+describe("MatrixClient retrying", function () {
+    const userId = "@alice:localhost";
+    const accessToken = "aseukfgwef";
+    const roomId = "!room:here";
+    let client: MatrixClient | undefined;
+    let httpBackend: HttpBackend | undefined;
+    let room: Room | undefined;
+
+    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();
+    });
+
+    it.skip("should retry according to MatrixScheduler.retryFn", function () {});
+
+    it.skip("should queue according to MatrixScheduler.queueFn", function () {});
+
+    it.skip("should mark events as EventStatus.NOT_SENT when giving up", function () {});
+
+    it.skip("should mark events as EventStatus.QUEUED when queued", 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: MsgType.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: MsgType.Text,
+            body: "m2",
+        });
+
+        // both events should be in the timeline at this point
+        const tl = room!.getLiveTimeline().getEvents();
+        expect(tl.length).toEqual(2);
+        const ev1 = tl[0];
+        const ev2 = tl[1];
+
+        expect(ev1.status).toEqual(EventStatus.SENDING);
+        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);
+
+                // 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
+
+        // wait for the localecho of ev1 to be updated
+        const p3 = new Promise<void>((resolve, reject) => {
+            room!.on(RoomEvent.LocalEchoUpdated, (ev0) => {
+                if (ev0 === ev1) {
+                    resolve();
+                }
+            });
+        }).then(function () {
+            expect(ev1.status).toEqual(EventStatus.NOT_SENT);
+            expect(tl.length).toEqual(1);
+
+            // cancel the first message
+            client!.cancelPendingEvent(ev1);
+            expect(ev1.status).toEqual(EventStatus.CANCELLED);
+            expect(tl.length).toEqual(0);
+        });
+
+        return Promise.all([p1, p3, httpBackend!.flushAllExpected()]);
+    });
+
+    describe("resending", function () {
+        it.skip("should be able to resend a NOT_SENT event", function () {});
+        it.skip("should be able to resend a sent event", function () {});
+    });
+});

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

@@ -1,608 +0,0 @@
-import * as utils from "../test-utils";
-import { EventStatus } from "../../src/models/event";
-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(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", "/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 httpBackend.flush("/pushrules").then(function() {
-            return 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("/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 'Room.timelineReset' event", 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);
-                });
-            });
-        });
-    });
-});

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

@@ -0,0 +1,873 @@
+/*
+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";
+import { KnownMembership } from "../../src/@types/membership";
+
+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: KnownMembership.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: KnownMembership.Join,
+                                user: otherUserId,
+                                name: "Bob",
+                            }),
+                            USER_MEMBERSHIP_EVENT,
+                            utils.mkEvent({
+                                type: "m.room.create",
+                                room: roomId,
+                                user: userId,
+                                content: {},
+                            }),
+                        ],
+                    },
+                },
+            },
+        },
+    };
+
+    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",
+            async () => {
+                const wasMessageAddedPromise = new Promise((resolve) => {
+                    client!.on(ClientEvent.Sync, async (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);
+
+                        await httpBackend!.flush("/sync", 1);
+                        resolve(null);
+                    });
+                });
+                await httpBackend!.flush("/sync", 1);
+                await wasMessageAddedPromise;
+            },
+        );
+
+        it(
+            "should be updated correctly when the send request finishes " +
+                "BEFORE the event comes down the event stream",
+            async () => {
+                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]);
+
+                const wasMessageAddedPromise = new Promise((resolve) => {
+                    client!.on(ClientEvent.Sync, function (state) {
+                        if (state !== "PREPARED") {
+                            return;
+                        }
+                        const room = client!.getRoom(roomId)!;
+                        client!.sendTextMessage(roomId, "I am a fish", "txn1").then(async () => {
+                            expect(room.timeline[1].getId()).toEqual(eventId);
+                            await httpBackend!.flush("/sync", 1);
+                            expect(room.timeline[1].getId()).toEqual(eventId);
+                            resolve(null);
+                        });
+                        httpBackend!.flush("/txn1", 1);
+                    });
+                });
+                await httpBackend!.flush("/sync", 1);
+                await wasMessageAddedPromise;
+            },
+        );
+
+        it(
+            "should be updated correctly when the send request finishes " +
+                "AFTER the event comes down the event stream",
+            async () => {
+                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]);
+
+                const wasMessageAddedPromise = new Promise((resolve) => {
+                    client!.on(ClientEvent.Sync, async (state) => {
+                        if (state !== "PREPARED") {
+                            return;
+                        }
+                        const room = client!.getRoom(roomId)!;
+                        const messageSendPromise = client!.sendTextMessage(roomId, "I am a fish", "txn1");
+                        await httpBackend!.flush("/sync", 1);
+                        expect(room.timeline.length).toEqual(2);
+                        httpBackend!.flush("/txn1", 1);
+                        await messageSendPromise;
+                        expect(room.timeline.length).toEqual(2);
+                        expect(room.timeline[1].getId()).toEqual(eventId);
+                        resolve(null);
+                    });
+                });
+                await httpBackend!.flush("/sync", 1);
+                await wasMessageAddedPromise;
+            },
+        );
+    });
+
+    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.", async () => {
+            const didPaginatePromise = new Promise((resolve) => {
+                client!.on(ClientEvent.Sync, async (state) => {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    expect(room.timeline.length).toEqual(1);
+
+                    await Promise.all([client!.scrollback(room), httpBackend!.flush("/messages", 1)]);
+                    expect(room.timeline.length).toEqual(1);
+                    expect(room.oldState.paginationToken).toBe(null);
+
+                    // still have a sync to flush
+                    await httpBackend!.flush("/sync", 1);
+                    resolve(null);
+                });
+            });
+            await httpBackend!.flush("/sync", 1);
+            await didPaginatePromise;
+        });
+
+        it("should set the right event.sender values", async () => {
+            // 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: KnownMembership.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: KnownMembership.Join,
+                user: userId,
+                room: roomId,
+                name: userName,
+                url: "mxc://some/url",
+            });
+            oldMshipEvent.unsigned!.prev_content = {
+                displayname: "Old Alice",
+                avatar_url: undefined,
+                membership: KnownMembership.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,
+            ];
+
+            const didPaginatePromise = new Promise((resolve) => {
+                client!.on(ClientEvent.Sync, async (state) => {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    // sync response
+                    expect(room.timeline.length).toEqual(1);
+
+                    await Promise.all([client!.scrollback(room), httpBackend!.flush("/messages", 1)]);
+
+                    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
+                    await httpBackend!.flush("/sync", 1);
+                    resolve(null);
+                });
+            });
+            await httpBackend!.flush("/sync", 1);
+            await didPaginatePromise;
+        });
+
+        it("should add it them to the right place in the timeline", async () => {
+            // 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",
+                }),
+            ];
+
+            const didPaginatePromise = new Promise((resolve) => {
+                client!.on(ClientEvent.Sync, async (state) => {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    expect(room.timeline.length).toEqual(1);
+
+                    await Promise.all([client!.scrollback(room), httpBackend!.flush("/messages", 1)]);
+
+                    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
+                    await httpBackend!.flush("/sync", 1);
+                    resolve(null);
+                });
+            });
+            await httpBackend!.flush("/sync", 1);
+            await didPaginatePromise;
+        });
+
+        it("should use 'end' as the next pagination token", async () => {
+            // set the list of events to return on scrollback
+            sbEvents = [
+                utils.mkMessage({
+                    user: userId,
+                    room: roomId,
+                    msg: "I am new",
+                }),
+            ];
+
+            const didPaginatePromise = new Promise((resolve) => {
+                client!.on(ClientEvent.Sync, async (state) => {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    expect(room.oldState.paginationToken).toBeTruthy();
+
+                    await Promise.all([client!.scrollback(room, 1), httpBackend!.flush("/messages", 1)]);
+                    expect(room.oldState.paginationToken).toEqual(sbEndTok);
+
+                    // still have a sync to flush
+                    await httpBackend!.flush("/sync", 1);
+                    resolve(null);
+                });
+            });
+            await httpBackend!.flush("/sync", 1);
+            await didPaginatePromise;
+        });
+    });
+
+    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: KnownMembership.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: KnownMembership.Join,
+                    name: "C",
+                }),
+                utils.mkMembership({
+                    user: userC,
+                    room: roomId,
+                    mship: KnownMembership.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(KnownMembership.Join);
+                    expect(room.currentState.getMember(userD)!.name).toEqual(userD);
+                    expect(room.currentState.getMember(userD)!.membership).toEqual(KnownMembership.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(KnownMembership.Join);
+                    expect(room.currentState.getMember(otherUserId)!.name).toEqual("Bob");
+                    expect(room.currentState.getMember(otherUserId)!.membership).toEqual(KnownMembership.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/matrix-client-syncing-errors.spec.ts

@@ -0,0 +1,163 @@
+/*
+Copyright 2023 Holi Moli 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 "fake-indexeddb/auto";
+import fetchMock from "fetch-mock-jest";
+
+import { MatrixClient, ClientEvent, createClient, SyncState } from "../../src";
+
+const makeQueryablePromise = <T = void>(promise: Promise<T>) => {
+    let resolved = false;
+    let rejected = false;
+
+    // Observe the promise, saving the fulfillment in a closure scope.
+    const newPromise = promise.then(
+        (value) => {
+            resolved = true;
+            return value;
+        },
+        (error) => {
+            rejected = true;
+            throw error;
+        },
+    );
+    const isFulfilled = () => {
+        return resolved || rejected;
+    };
+    const isResolved = () => {
+        return resolved;
+    };
+    const isRejected = () => {
+        return rejected;
+    };
+    return { promise: newPromise, isFulfilled, isResolved, isRejected };
+};
+
+const queryablePromise = <T = void>() => {
+    let resolve!: (value: T | PromiseLike<T>) => void;
+    let reject!: (reason?: any) => void;
+
+    const promise = makeQueryablePromise<T>(
+        new Promise<T>((_resolve, _reject) => {
+            resolve = _resolve;
+            reject = _reject;
+        }),
+    );
+
+    return { resolve, reject, ...promise };
+};
+
+describe("MatrixClient syncing errors", () => {
+    const selfUserId = "@alice:localhost";
+    const selfAccessToken = "aseukfgwef";
+    const unknownTokenErrorData = {
+        status: 401,
+        body: {
+            errcode: "M_UNKNOWN_TOKEN",
+            error: "Invalid access token passed.",
+            soft_logout: false,
+        },
+    };
+    let client: MatrixClient | undefined;
+
+    beforeEach(() => {
+        client = createClient({
+            baseUrl: "http://tocal.test.server",
+            userId: selfUserId,
+            accessToken: selfAccessToken,
+            deviceId: "myDevice",
+        });
+    });
+
+    it("should retry, until errors are solved.", async () => {
+        jest.useFakeTimers();
+        fetchMock.config.overwriteRoutes = false;
+        fetchMock
+            .getOnce("end:versions", {}) // first version check without credentials needs to succeed
+            .getOnce("end:versions", 429) // second version check fails with 429 triggering another retry
+            .get("end:versions", {}) // further version checks succeed
+            .getOnce("end:pushrules/", 429) // first pushrules check fails starting retry
+            .get("end:pushrules/", {}) // further pushrules check succeed
+            .catch({}); // all other calls succeed
+
+        const syncEvents = Array.from({ length: 5 }, queryablePromise<SyncState>);
+
+        client!.on(ClientEvent.Sync, (state: SyncState, lastState: SyncState | null) => {
+            let i = 0;
+            for (; i < syncEvents.length && syncEvents[i].isFulfilled(); i++) {
+                // find index of first unfulfilled promise
+            }
+            syncEvents[i].resolve(state);
+        });
+
+        await client!.startClient();
+        expect(await syncEvents[0].promise).toBe(SyncState.Error);
+        jest.advanceTimersByTime(60 * 1000); // this will skip forward to trigger the keepAlive/sync
+        expect(await syncEvents[1].promise).toBe(SyncState.Error);
+        jest.advanceTimersByTime(60 * 1000); // this will skip forward to trigger the keepAlive/sync
+        expect(await syncEvents[2].promise).toBe(SyncState.Prepared);
+        jest.advanceTimersByTime(60 * 1000); // this will skip forward to trigger the keepAlive/sync
+        expect(await syncEvents[3].promise).toBe(SyncState.Syncing);
+        jest.advanceTimersByTime(60 * 1000); // this will skip forward to trigger the keepAlive/sync
+        expect(await syncEvents[4].promise).toBe(SyncState.Syncing);
+    });
+
+    it("should stop sync keep alive when client is stopped.", async () => {
+        jest.useFakeTimers();
+        fetchMock.config.overwriteRoutes = false;
+        fetchMock
+            .get("end:capabilities", {})
+            .getOnce("end:versions", {}) // first version check without credentials needs to succeed
+            .get("end:versions", unknownTokenErrorData) // further version checks fails with 401
+            .get("end:pushrules/", 401) // fails with 401 without an error. This does happen in practice e.g. with Synapse
+            .post("end:logout", unknownTokenErrorData) // just to keep up a consistent scenario. Does not have a real effect for this testcase
+            .post("end:filter", 401); // just to keep up a consistent scenario. Does not have a real effect for this testcase
+
+        const firstSyncEvent = queryablePromise<SyncState>();
+        const secondSyncEvent = queryablePromise<SyncState>();
+        client!.on(ClientEvent.Sync, (state: SyncState, lastState: SyncState | null) => {
+            if (firstSyncEvent.isFulfilled()) secondSyncEvent.resolve(state);
+            firstSyncEvent.resolve(state);
+        });
+
+        await client!.startClient();
+        const logoutDone = queryablePromise();
+        client!
+            .logout(true)
+            .then(() => {
+                logoutDone.resolve();
+            })
+            .catch((e) => {
+                logoutDone.resolve();
+            });
+
+        const syntState = await firstSyncEvent.promise;
+        expect(syntState).toBe(SyncState.Error);
+        jest.runAllTimers(); // this will skip forward to trigger the keepAlive
+
+        jest.useRealTimers(); // we need real timer for the setTimout below to work
+
+        const timeoutPromise = makeQueryablePromise(new Promise<void>((res) => setTimeout(res, 1)));
+
+        await Promise.race([secondSyncEvent.promise, timeoutPromise.promise]);
+        // when syncing stopped, then the secondSyncEvent will never happen and the promise will not be resolved,
+        /// so the timeoutPromise will be resolved instead
+        expect(timeoutPromise.isFulfilled()).toBe(true);
+        expect(secondSyncEvent.isFulfilled()).toBe(false);
+
+        await logoutDone.promise; // wait for the logout to finish to prevent processing and logging after the test is done.
+    });
+});

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

@@ -1,755 +0,0 @@
-import { MatrixEvent } from "../../src/models/event";
-import { EventTimeline } from "../../src/models/event-timeline";
-import * as utils from "../test-utils";
-import { TestClient } from "../TestClient";
-
-describe("MatrixClient syncing", function() {
-    let client = null;
-    let httpBackend = null;
-    const selfUserId = "@alice:localhost";
-    const selfAccessToken = "aseukfgwef";
-    const otherUserId = "@bob:localhost";
-    const userA = "@alice:bar";
-    const userB = "@bob:bar";
-    const userC = "@claire:bar";
-    const roomOne = "!foo:localhost";
-    const roomTwo = "!bar:localhost";
-
-    beforeEach(function() {
-        const testClient = new TestClient(selfUserId, "DEVICE", selfAccessToken);
-        httpBackend = testClient.httpBackend;
-        client = testClient.client;
-        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("startClient", function() {
-        const syncData = {
-            next_batch: "batch_token",
-            rooms: {},
-            presence: {},
-        };
-
-        it("should /sync after /pushrules and /filter.", function(done) {
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            client.startClient();
-
-            httpBackend.flushAllExpected().then(function() {
-                done();
-            });
-        });
-
-        it("should pass the 'next_batch' token from /sync to the since= param " +
-            " of the next /sync", function(done) {
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-            httpBackend.when("GET", "/sync").check(function(req) {
-                expect(req.queryParams.since).toEqual(syncData.next_batch);
-            }).respond(200, syncData);
-
-            client.startClient();
-
-            httpBackend.flushAllExpected().then(function() {
-                done();
-            });
-        });
-    });
-
-    describe("resolving invites to profile info", function() {
-        const syncData = {
-            next_batch: "s_5_3",
-            presence: {
-                events: [],
-            },
-            rooms: {
-                join: {
-
-                },
-            },
-        };
-
-        beforeEach(function() {
-            syncData.presence.events = [];
-            syncData.rooms.join[roomOne] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomOne, user: otherUserId, msg: "hello",
-                        }),
-                    ],
-                },
-                state: {
-                    events: [
-                        utils.mkMembership({
-                            room: roomOne, mship: "join", user: otherUserId,
-                        }),
-                        utils.mkMembership({
-                            room: roomOne, mship: "join", user: selfUserId,
-                        }),
-                        utils.mkEvent({
-                            type: "m.room.create", room: roomOne, user: selfUserId,
-                            content: {
-                                creator: selfUserId,
-                            },
-                        }),
-                    ],
-                },
-            };
-        });
-
-        it("should resolve incoming invites from /sync", function() {
-            syncData.rooms.join[roomOne].state.events.push(
-                utils.mkMembership({
-                    room: roomOne, mship: "invite", user: userC,
-                }),
-            );
-
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-            httpBackend.when("GET", "/profile/" + encodeURIComponent(userC)).respond(
-                200, {
-                    avatar_url: "mxc://flibble/wibble",
-                    displayname: "The Boss",
-                },
-            );
-
-            client.startClient({
-                resolveInvitesToProfiles: true,
-            });
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(function() {
-                const member = client.getRoom(roomOne).getMember(userC);
-                expect(member.name).toEqual("The Boss");
-                expect(
-                    member.getAvatarUrl("home.server.url", null, null, null, false),
-                ).toBeTruthy();
-            });
-        });
-
-        it("should use cached values from m.presence wherever possible", function() {
-            syncData.presence.events = [
-                utils.mkPresence({
-                    user: userC, presence: "online", name: "The Ghost",
-                }),
-            ];
-            syncData.rooms.join[roomOne].state.events.push(
-                utils.mkMembership({
-                    room: roomOne, mship: "invite", user: userC,
-                }),
-            );
-
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            client.startClient({
-                resolveInvitesToProfiles: true,
-            });
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(function() {
-                const member = client.getRoom(roomOne).getMember(userC);
-                expect(member.name).toEqual("The Ghost");
-            });
-        });
-
-        it("should result in events on the room member firing", function() {
-            syncData.presence.events = [
-                utils.mkPresence({
-                    user: userC, presence: "online", name: "The Ghost",
-                }),
-            ];
-            syncData.rooms.join[roomOne].state.events.push(
-                utils.mkMembership({
-                    room: roomOne, mship: "invite", user: userC,
-                }),
-            );
-
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            let latestFiredName = null;
-            client.on("RoomMember.name", function(event, m) {
-                if (m.userId === userC && m.roomId === roomOne) {
-                    latestFiredName = m.name;
-                }
-            });
-
-            client.startClient({
-                resolveInvitesToProfiles: true,
-            });
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(function() {
-                expect(latestFiredName).toEqual("The Ghost");
-            });
-        });
-
-        it("should no-op if resolveInvitesToProfiles is not set", function() {
-            syncData.rooms.join[roomOne].state.events.push(
-                utils.mkMembership({
-                    room: roomOne, mship: "invite", user: userC,
-                }),
-            );
-
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            client.startClient();
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(function() {
-                const member = client.getRoom(roomOne).getMember(userC);
-                expect(member.name).toEqual(userC);
-                expect(
-                    member.getAvatarUrl("home.server.url", null, null, null, false),
-                ).toBe(null);
-            });
-        });
-    });
-
-    describe("users", function() {
-        const syncData = {
-            next_batch: "nb",
-            presence: {
-                events: [
-                    utils.mkPresence({
-                        user: userA, presence: "online",
-                    }),
-                    utils.mkPresence({
-                        user: userB, presence: "unavailable",
-                    }),
-                ],
-            },
-        };
-
-        it("should create users for presence events from /sync",
-        function() {
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            client.startClient();
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(function() {
-                expect(client.getUser(userA).presence).toEqual("online");
-                expect(client.getUser(userB).presence).toEqual("unavailable");
-            });
-        });
-    });
-
-    describe("room state", function() {
-        const msgText = "some text here";
-        const otherDisplayName = "Bob Smith";
-
-        const syncData = {
-            rooms: {
-                join: {
-
-                },
-            },
-        };
-        syncData.rooms.join[roomOne] = {
-            timeline: {
-                events: [
-                    utils.mkMessage({
-                        room: roomOne, user: otherUserId, msg: "hello",
-                    }),
-                ],
-            },
-            state: {
-                events: [
-                    utils.mkEvent({
-                        type: "m.room.name", room: roomOne, user: otherUserId,
-                        content: {
-                            name: "Old room name",
-                        },
-                    }),
-                    utils.mkMembership({
-                        room: roomOne, mship: "join", user: otherUserId,
-                    }),
-                    utils.mkMembership({
-                        room: roomOne, mship: "join", user: selfUserId,
-                    }),
-                    utils.mkEvent({
-                        type: "m.room.create", room: roomOne, user: selfUserId,
-                        content: {
-                            creator: selfUserId,
-                        },
-                    }),
-                ],
-            },
-        };
-        syncData.rooms.join[roomTwo] = {
-            timeline: {
-                events: [
-                    utils.mkMessage({
-                        room: roomTwo, user: otherUserId, msg: "hiii",
-                    }),
-                ],
-            },
-            state: {
-                events: [
-                    utils.mkMembership({
-                        room: roomTwo, mship: "join", user: otherUserId,
-                        name: otherDisplayName,
-                    }),
-                    utils.mkMembership({
-                        room: roomTwo, mship: "join", user: selfUserId,
-                    }),
-                    utils.mkEvent({
-                        type: "m.room.create", room: roomTwo, user: selfUserId,
-                        content: {
-                            creator: selfUserId,
-                        },
-                    }),
-                ],
-            },
-        };
-
-        const nextSyncData = {
-            rooms: {
-                join: {
-
-                },
-            },
-        };
-
-        nextSyncData.rooms.join[roomOne] = {
-            state: {
-                events: [
-                    utils.mkEvent({
-                        type: "m.room.name", room: roomOne, user: selfUserId,
-                        content: { name: "A new room name" },
-                    }),
-                ],
-            },
-        };
-
-        nextSyncData.rooms.join[roomTwo] = {
-            timeline: {
-                events: [
-                    utils.mkMessage({
-                        room: roomTwo, user: otherUserId, msg: msgText,
-                    }),
-                ],
-            },
-            ephemeral: {
-                events: [
-                    utils.mkEvent({
-                        type: "m.typing", room: roomTwo,
-                        content: { user_ids: [otherUserId] },
-                    }),
-                ],
-            },
-        };
-
-        it("should continually recalculate the right room name.", function() {
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-            httpBackend.when("GET", "/sync").respond(200, nextSyncData);
-
-            client.startClient();
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(function() {
-                const room = client.getRoom(roomOne);
-                // should have clobbered the name to the one from /events
-                expect(room.name).toEqual(
-                    nextSyncData.rooms.join[roomOne].state.events[0].content.name,
-                );
-            });
-        });
-
-        it("should store the right events in the timeline.", function() {
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-            httpBackend.when("GET", "/sync").respond(200, nextSyncData);
-
-            client.startClient();
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(function() {
-                const room = client.getRoom(roomTwo);
-                // should have added the message from /events
-                expect(room.timeline.length).toEqual(2);
-                expect(room.timeline[1].getContent().body).toEqual(msgText);
-            });
-        });
-
-        it("should set the right room name.", function() {
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-            httpBackend.when("GET", "/sync").respond(200, nextSyncData);
-
-            client.startClient();
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(function() {
-                const room = client.getRoom(roomTwo);
-                // should use the display name of the other person.
-                expect(room.name).toEqual(otherDisplayName);
-            });
-        });
-
-        it("should set the right user's typing flag.", function() {
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-            httpBackend.when("GET", "/sync").respond(200, nextSyncData);
-
-            client.startClient();
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(function() {
-                const room = client.getRoom(roomTwo);
-                let member = room.getMember(otherUserId);
-                expect(member).toBeTruthy();
-                expect(member.typing).toEqual(true);
-                member = room.getMember(selfUserId);
-                expect(member).toBeTruthy();
-                expect(member.typing).toEqual(false);
-            });
-        });
-
-        // XXX: This test asserts that the js-sdk obeys the spec and treats state
-        // events that arrive in the incremental sync as if they preceeded the
-        // timeline events, however this breaks peeking, so it's disabled
-        // (see sync.js)
-        xit("should correctly interpret state in incremental sync.", function() {
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-            httpBackend.when("GET", "/sync").respond(200, nextSyncData);
-
-            client.startClient();
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(function() {
-                const room = client.getRoom(roomOne);
-                const stateAtStart = room.getLiveTimeline().getState(
-                    EventTimeline.BACKWARDS,
-                );
-                const startRoomNameEvent = stateAtStart.getStateEvents('m.room.name', '');
-                expect(startRoomNameEvent.getContent().name).toEqual('Old room name');
-
-                const stateAtEnd = room.getLiveTimeline().getState(
-                    EventTimeline.FORWARDS,
-                );
-                const endRoomNameEvent = stateAtEnd.getStateEvents('m.room.name', '');
-                expect(endRoomNameEvent.getContent().name).toEqual('A new room name');
-            });
-        });
-
-        xit("should update power levels for users in a room", function() {
-
-        });
-
-        xit("should update the room topic", function() {
-
-        });
-    });
-
-    describe("timeline", function() {
-        beforeEach(function() {
-            const syncData = {
-                next_batch: "batch_token",
-                rooms: {
-                    join: {},
-                },
-            };
-            syncData.rooms.join[roomOne] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomOne, user: otherUserId, msg: "hello",
-                        }),
-                    ],
-                    prev_batch: "pagTok",
-                },
-            };
-
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            client.startClient();
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(),
-            ]);
-        });
-
-        it("should set the back-pagination token on new rooms", function() {
-            const syncData = {
-                next_batch: "batch_token",
-                rooms: {
-                    join: {},
-                },
-            };
-            syncData.rooms.join[roomTwo] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomTwo, user: otherUserId, msg: "roomtwo",
-                        }),
-                    ],
-                    prev_batch: "roomtwotok",
-                },
-            };
-
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(function() {
-                const room = client.getRoom(roomTwo);
-                expect(room).toBeDefined();
-                const tok = room.getLiveTimeline()
-                    .getPaginationToken(EventTimeline.BACKWARDS);
-                expect(tok).toEqual("roomtwotok");
-            });
-        });
-
-        it("should set the back-pagination token on gappy syncs", function() {
-            const syncData = {
-                next_batch: "batch_token",
-                rooms: {
-                    join: {},
-                },
-            };
-            syncData.rooms.join[roomOne] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomOne, user: otherUserId, msg: "world",
-                        }),
-                    ],
-                    limited: true,
-                    prev_batch: "newerTok",
-                },
-            };
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            let resetCallCount = 0;
-            // the token should be set *before* timelineReset is emitted
-            client.on("Room.timelineReset", function(room) {
-                resetCallCount++;
-
-                const tl = room.getLiveTimeline();
-                expect(tl.getEvents().length).toEqual(0);
-                const tok = tl.getPaginationToken(EventTimeline.BACKWARDS);
-                expect(tok).toEqual("newerTok");
-            });
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(function() {
-                const room = client.getRoom(roomOne);
-                const tl = room.getLiveTimeline();
-                expect(tl.getEvents().length).toEqual(1);
-                expect(resetCallCount).toEqual(1);
-            });
-        });
-    });
-
-    describe("receipts", function() {
-        const syncData = {
-            rooms: {
-                join: {
-
-                },
-            },
-        };
-        syncData.rooms.join[roomOne] = {
-            timeline: {
-                events: [
-                    utils.mkMessage({
-                        room: roomOne, user: otherUserId, msg: "hello",
-                    }),
-                    utils.mkMessage({
-                        room: roomOne, user: otherUserId, msg: "world",
-                    }),
-                ],
-            },
-            state: {
-                events: [
-                    utils.mkEvent({
-                        type: "m.room.name", room: roomOne, user: otherUserId,
-                        content: {
-                            name: "Old room name",
-                        },
-                    }),
-                    utils.mkMembership({
-                        room: roomOne, mship: "join", user: otherUserId,
-                    }),
-                    utils.mkMembership({
-                        room: roomOne, mship: "join", user: selfUserId,
-                    }),
-                    utils.mkEvent({
-                        type: "m.room.create", room: roomOne, user: selfUserId,
-                        content: {
-                            creator: selfUserId,
-                        },
-                    }),
-                ],
-            },
-        };
-
-        beforeEach(function() {
-            syncData.rooms.join[roomOne].ephemeral = {
-                events: [],
-            };
-        });
-
-        it("should sync receipts from /sync.", function() {
-            const ackEvent = syncData.rooms.join[roomOne].timeline.events[0];
-            const receipt = {};
-            receipt[ackEvent.event_id] = {
-                "m.read": {},
-            };
-            receipt[ackEvent.event_id]["m.read"][userC] = {
-                ts: 176592842636,
-            };
-            syncData.rooms.join[roomOne].ephemeral.events = [{
-                content: receipt,
-                room_id: roomOne,
-                type: "m.receipt",
-            }];
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            client.startClient();
-
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(function() {
-                const room = client.getRoom(roomOne);
-                expect(room.getReceiptsForEvent(new MatrixEvent(ackEvent))).toEqual([{
-                    type: "m.read",
-                    userId: userC,
-                    data: {
-                        ts: 176592842636,
-                    },
-                }]);
-            });
-        });
-    });
-
-    describe("of a room", function() {
-        xit("should sync when a join event (which changes state) for the user" +
-        " arrives down the event stream (e.g. join from another device)", function() {
-
-        });
-
-        xit("should sync when the user explicitly calls joinRoom", function() {
-
-        });
-    });
-
-    describe("syncLeftRooms", function() {
-        beforeEach(function(done) {
-            client.startClient();
-
-            httpBackend.flushAllExpected().then(function() {
-                // the /sync call from syncLeftRooms ends up in the request
-                // queue behind the call from the running client; add a response
-                // to flush the client's one out.
-                httpBackend.when("GET", "/sync").respond(200, {});
-
-                done();
-            });
-        });
-
-        it("should create and use an appropriate filter", function() {
-            httpBackend.when("POST", "/filter").check(function(req) {
-                expect(req.data).toEqual({
-                    room: { timeline: { limit: 1 },
-                            include_leave: true } });
-            }).respond(200, { filter_id: "another_id" });
-
-            const prom = new Promise((resolve) => {
-                httpBackend.when("GET", "/sync").check(function(req) {
-                    expect(req.queryParams.filter).toEqual("another_id");
-                    resolve();
-                }).respond(200, {});
-            });
-
-            client.syncLeftRooms();
-
-            // first flush the filter request; this will make syncLeftRooms
-            // make its /sync call
-            return Promise.all([
-                httpBackend.flush("/filter").then(function() {
-                    // flush the syncs
-                    return httpBackend.flushAllExpected();
-                }),
-                prom,
-            ]);
-        });
-
-        it("should set the back-pagination token on left rooms", function() {
-            const syncData = {
-                next_batch: "batch_token",
-                rooms: {
-                    leave: {},
-                },
-            };
-
-            syncData.rooms.leave[roomTwo] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomTwo, user: otherUserId, msg: "hello",
-                        }),
-                    ],
-                    prev_batch: "pagTok",
-                },
-            };
-
-            httpBackend.when("POST", "/filter").respond(200, {
-                filter_id: "another_id",
-            });
-
-            httpBackend.when("GET", "/sync").respond(200, syncData);
-
-            return Promise.all([
-                client.syncLeftRooms().then(function() {
-                    const room = client.getRoom(roomTwo);
-                    const tok = room.getLiveTimeline().getPaginationToken(
-                        EventTimeline.BACKWARDS);
-
-                    expect(tok).toEqual("pagTok");
-                }),
-
-                // first flush the filter request; this will make syncLeftRooms
-                // make its /sync call
-                httpBackend.flush("/filter").then(function() {
-                    return httpBackend.flushAllExpected();
-                }),
-            ]);
-        });
-    });
-
-    /**
-     * waits for the MatrixClient to emit one or more 'sync' events.
-     *
-     * @param {Number?} numSyncs number of syncs to wait for
-     * @returns {Promise} promise which resolves after the sync events have happened
-     */
-    function awaitSyncEvent(numSyncs) {
-        return utils.syncPromise(client, numSyncs);
-    }
-});