v0.9.2-cryptowraning.1

Prepare changelog for v0.9.2-cryptowraning.1
Merge pull request #631 from matrix-org/dbkr/cryptowarning
2018-03-26 14:11:29 +01:00 · 2018-03-26 14:11:29 +01:00 · 2018-03-26 14:04:42 +01:00 · 2018-03-26 13:57:37 +01:00 · 2018-03-23 17:29:35 +00:00
502 changed files with 37220 additions and 155560 deletions
@@ -1,22 +1,13 @@
 {
-    "sourceMaps": true,
-    "presets": [
-        [
-            "@babel/preset-env",
-            {
-                "targets": {
-                    "node": 10
-                },
-                "modules": "commonjs"
-            }
-        ],
-        "@babel/preset-typescript"
-    ],
+    "presets": ["es2015"],
    "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"
-    ]
+        // this transforms async functions into generator functions, which
+        // are then made to use the regenerator module by babel's
+        // transform-regnerator plugin (which is enabled by es2015).
+        "transform-async-to-bluebird",
+
+        // This makes sure that the regenerator runtime is available to
+        // the transpiled code.
+        "transform-runtime",
+    ],
 }
@@ -21,6 +21,3 @@ insert_final_newline = true
 indent_style = space
 indent_size = 4
 trim_trailing_whitespace = true
-
-[*.{yml,yaml}]
-indent_size = 4
@@ -1,129 +1,71 @@
 module.exports = {
-    plugins: ["matrix-org", "import", "jsdoc"],
-    extends: ["plugin:matrix-org/babel", "plugin:matrix-org/jest", "plugin:import/typescript"],
+    parser: "babel-eslint",
    parserOptions: {
-        project: ["./tsconfig.json"],
+        ecmaVersion: 6,
+        sourceType: "module",
+        ecmaFeatures: {
+        }
    },
    env: {
        browser: true,
        node: true,
+
+        // babel's transform-runtime converts references to ES6 globals such as
+        // Promise and Map to core-js polyfills, so we can use ES6 globals.
+        es6: 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/
+    extends: ["eslint:recommended", "google"],
    rules: {
-        "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",
-        "no-constant-condition": "off",
-        "no-async-promise-executor": "off",
-        // We use a `logger` intermediary module
-        "no-console": "error",
+        // rules we've always adhered to or now do
+        "max-len": ["error", {
+            code: 90,
+            ignoreComments: true,
+        }],
+        curly: ["error", "multi-line"],
+        "prefer-const": ["error"],
+        "comma-dangle": ["error", {
+            arrays: "always-multiline",
+            objects: "always-multiline",
+            imports: "always-multiline",
+            exports: "always-multiline",
+            functions: "always-multiline",
+        }],

-        // restrict EventEmitters to force callers to use TypedEventEmitter
-        "no-restricted-imports": [
-            "error",
-            {
-                name: "events",
-                message: "Please use TypedEventEmitter instead",
-            },
-        ],
+        // loosen jsdoc requirements a little
+        "require-jsdoc": ["error", {
+            require: {
+                FunctionDeclaration: false,
+            }
+        }],
+        "valid-jsdoc": ["error", {
+            requireParamDescription: false,
+            requireReturn: false,
+            requireReturnDescription: false,
+        }],

-        "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"],
-            plugins: ["eslint-plugin-tsdoc"],
-            extends: ["plugin:matrix-org/typescript"],
-            rules: {
-                // TypeScript has its own version of this
-                "@babel/no-invalid-this": "off",
+        // rules we do not want from eslint-recommended
+        "no-console": ["off"],
+        "no-constant-condition": ["off"],
+        "no-empty": ["error", { "allowEmptyCatch": true }],

-                // 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",
+        // rules we do not want from the google styleguide
+        "object-curly-spacing": ["off"],
+        "spaced-comment": ["off"],

-                // The non-TypeScript rule produces false positives
-                "func-call-spacing": "off",
-                "@typescript-eslint/func-call-spacing": ["error"],
+        // in principle we prefer single quotes, but life is too short
+        quotes: ["off"],

-                "quotes": "off",
-                // We use a `logger` intermediary module
-                "no-console": "error",
-            },
-        },
-        {
-            // We don't need amazing docs in our spec files
-            files: ["src/**/*.ts"],
-            rules: {
-                "tsdoc/syntax": "error",
-                // We use some select jsdoc rules as the tsdoc linter has only one rule
-                "jsdoc/no-types": "error",
-                "jsdoc/empty-tags": "error",
-                "jsdoc/check-property-names": "error",
-                "jsdoc/check-values": "error",
-                // These need a bit more work before we can enable
-                // "jsdoc/check-param-names": "error",
-                // "jsdoc/check-indentation": "error",
-            },
-        },
-        {
-            files: ["spec/**/*.ts"],
-            rules: {
-                // We don't need super strict typing in test utilities
-                "@typescript-eslint/explicit-function-return-type": "off",
-                "@typescript-eslint/explicit-member-accessibility": "off",
-            },
-        },
-    ],
-};
+        // rules we'd ideally like to adhere to, but the current
+        // code does not (in most cases because it's still ES5)
+        // we set these to warnings, and assert that the number
+        // of warnings doesn't exceed a given threshold
+        "no-var": ["warn"],
+        "brace-style": ["warn", "1tbs", {"allowSingleLine": true}],
+        "prefer-rest-params": ["warn"],
+        "prefer-spread": ["warn"],
+        "one-var": ["warn"],
+        "padded-blocks": ["warn"],
+        "no-extend-native": ["warn"],
+        "camelcase": ["warn"],
+    }
+}
@@ -1,42 +0,0 @@
-# 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
@@ -1,8 +0,0 @@
-*                         @matrix-org/element-web
-/.github/workflows/**     @matrix-org/element-web-app-team
-/package.json             @matrix-org/element-web-app-team
-/yarn.lock                @matrix-org/element-web-app-team
-/src/webrtc               @matrix-org/element-call-reviewers
-/src/matrixrtc               @matrix-org/element-call-reviewers
-/spec/*/webrtc            @matrix-org/element-call-reviewers
-/spec/*/matrixrtc            @matrix-org/element-call-reviewers
@@ -1,2 +0,0 @@
-patreon: matrixdotorg
-liberapay: matrixdotorg
@@ -1,13 +0,0 @@
-<!-- Thanks for submitting a PR! Please ensure the following requirements are met in order for us to review your PR -->
-
-## Checklist
-
-   [ ] Tests written for new code (and old code if feasible)
-   [ ] Linter and other CI checks pass
-   [ ] Sign-off given on the changes (see [CONTRIBUTING.md](https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md))
-
-<!--
-If you would like to specify text for the changelog entry other than your PR title, add the following:
-
-Notes: Add super cool feature
-->
@@ -1,4 +0,0 @@
-{
-    "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-    "extends": ["github>matrix-org/renovate-config-element-web"]
-}
@@ -1,30 +0,0 @@
-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 }}
@@ -1,31 +0,0 @@
-# Triggers after the "Downstream artifacts" build has finished, to run the
-# cypress tests (with access to repo secrets)
-
-name: matrix-react-sdk Cypress End to End Tests
-on:
-    workflow_run:
-        workflows: ["Build downstream artifacts"]
-        types:
-            - completed
-
-concurrency:
-    group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch || github.run_id }}
-    cancel-in-progress: ${{ github.event.workflow_run.event == 'pull_request' }}
-
-jobs:
-    cypress:
-        name: Cypress
-        uses: matrix-org/matrix-react-sdk/.github/workflows/cypress.yaml@v3.79.0
-        permissions:
-            actions: read
-            issues: read
-            statuses: write
-            pull-requests: read
-        secrets:
-            # secrets are not automatically shared with called workflows, so share the cypress dashboard key, and the Kiwi login details
-            CYPRESS_RECORD_KEY: ${{ secrets.CYPRESS_RECORD_KEY }}
-            TCMS_USERNAME: ${{ secrets.TCMS_USERNAME }}
-            TCMS_PASSWORD: ${{ secrets.TCMS_PASSWORD }}
-        with:
-            react-sdk-repository: matrix-org/matrix-react-sdk
-            rust-crypto: true
@@ -1,34 +0,0 @@
-name: Deploy documentation PR preview
-
-on:
-    workflow_run:
-        workflows: ["Static Analysis"]
-        types:
-            - completed
-
-jobs:
-    netlify:
-        if: github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.event == 'pull_request'
-        runs-on: ubuntu-latest
-        steps:
-            # There's a 'download artifact' action, but it hasn't been updated for the workflow_run action
-            # (https://github.com/actions/download-artifact/issues/60) so instead we get this mess:
-            - name: 📥 Download artifact
-              uses: dawidd6/action-download-artifact@246dbf436b23d7c49e21a7ab8204ca9ecd1fe615 # v2
-              with:
-                  workflow: static_analysis.yml
-                  run_id: ${{ github.event.workflow_run.id }}
-                  name: docs
-                  path: docs
-
-            - name: 📤 Deploy to Netlify
-              uses: matrix-org/netlify-pr-preview@v2
-              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
@@ -1,27 +0,0 @@
-name: Build downstream artifacts
-on:
-    # We only want the Rust Crypto Cypress tests on merge queue to prevent regressions
-    # from creeping in. They take a long time to run and consume 4 concurrent runners.
-    # Anyone working on Rust Crypto is able to run the tests locally if required.
-    merge_group:
-        types: [checks_requested]
-
-    # For now at least, we don't run this or the cypress-tests against pushes
-    # to develop or master.
-    #
-    # Note that if we later choose to do so, we'll need to find a way to stop
-    # the results in Cypress Cloud from clobbering those from the 'develop'
-    # branch of matrix-react-sdk.
-    #
-    #push:
-    #    branches: [develop, master]
-concurrency:
-    group: ${{ github.workflow }}-${{ github.ref }}
-    cancel-in-progress: true
-jobs:
-    build-element-web:
-        name: Build element-web
-        uses: matrix-org/matrix-react-sdk/.github/workflows/element-web.yaml@v3.79.0
-        with:
-            matrix-js-sdk-sha: ${{ github.sha }}
-            react-sdk-repository: matrix-org/matrix-react-sdk
@@ -1,27 +0,0 @@
-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: vector-im/element-web
-                      event: element-web-notify
-                    - repo: matrix-org/matrix-react-sdk
-                      event: upstream-sdk-notify
-
-        runs-on: ubuntu-latest
-        steps:
-            - name: Notify matrix-react-sdk repo that a new SDK build is on develop so it can CI against it
-              uses: peter-evans/repository-dispatch@bf47d102fdb849e755b0b0023ea3e81a44b6f570 # v2
-              with:
-                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-                  repository: ${{ matrix.repo }}
-                  event-type: ${{ matrix.event }}
@@ -1,88 +0,0 @@
-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: matrix-org/allchange@main
-              if: github.event_name != 'merge_group'
-              with:
-                  ghToken: ${{ secrets.GITHUB_TOKEN }}
-                  requireLabel: true
-
-    prevent-blocked:
-        name: Prevent Blocked
-        runs-on: ubuntu-latest
-        permissions:
-            pull-requests: read
-        steps:
-            - name: Add notice
-              uses: actions/github-script@v6
-              if: contains(github.event.pull_request.labels.*.name, 'X-Blocked')
-              with:
-                  script: |
-                      core.setFailed("Preventing merge whilst PR is marked blocked!");
-
-    community-prs:
-        name: Label Community PRs
-        runs-on: ubuntu-latest
-        if: github.event.action == 'opened'
-        steps:
-            - name: Check membership
-              uses: tspascoal/get-user-teams-membership@37c08f7b52a72ca95d12af2e7ab2553ca9adf13b # v2
-              id: teams
-              with:
-                  username: ${{ github.event.pull_request.user.login }}
-                  organization: matrix-org
-                  team: Core Team
-                  GITHUB_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}
-
-            - name: Add label
-              if: ${{ steps.teams.outputs.isTeamMember == 'false' }}
-              uses: actions/github-script@v6
-              with:
-                  script: |
-                      github.rest.issues.addLabels({
-                        issue_number: context.issue.number,
-                        owner: context.repo.owner,
-                        repo: context.repo.repo,
-                        labels: ['Z-Community-PR']
-                      });
-
-    close-if-fork-develop:
-        name: Forbid develop branch fork contributions
-        runs-on: ubuntu-latest
-        if: >
-            github.event.action == 'opened' &&
-            github.event.pull_request.head.ref == 'develop' &&
-            github.event.pull_request.head.repo.full_name != github.repository
-        steps:
-            - name: Close pull request
-              uses: actions/github-script@v6
-              with:
-                  script: |
-                      github.rest.issues.createComment({
-                        issue_number: context.issue.number,
-                        owner: context.repo.owner,
-                        repo: context.repo.repo,
-                        body: "Thanks for opening this pull request, unfortunately we do not accept contributions from the main" +
-                          " branch of your fork, please re-open once you switch to an alternative branch for everyone's sanity." +
-                          " See https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md",
-                      });
-
-                      github.rest.pulls.update({
-                        pull_number: context.issue.number,
-                        owner: context.repo.owner,
-                        repo: context.repo.repo,
-                        state: 'closed'
-                      });
@@ -1,39 +0,0 @@
-# Must only be called from `release#published` triggers
-name: Publish to npm
-on:
-    workflow_call:
-        secrets:
-            NPM_TOKEN:
-                required: true
-jobs:
-    npm:
-        name: Publish to npm
-        runs-on: ubuntu-latest
-        steps:
-            - name: 🧮 Checkout code
-              uses: actions/checkout@v4
-
-            - name: 🔧 Yarn cache
-              uses: actions/setup-node@v3
-              with:
-                  cache: "yarn"
-                  registry-url: "https://registry.npmjs.org"
-
-            - name: 🔨 Install dependencies
-              run: "yarn install --frozen-lockfile"
-
-            - name: 🚀 Publish to npm
-              id: npm-publish
-              uses: JS-DevTools/npm-publish@5a85faf05d2ade2d5b6682bfe5359915d5159c6c # v2.2.1
-              with:
-                  token: ${{ secrets.NPM_TOKEN }}
-                  access: public
-                  tag: next
-                  ignore-scripts: false
-
-            - name: 🎖️ Add `latest` dist-tag to final releases
-              if: github.event.release.prerelease == false && steps.npm-publish.outputs.id
-              run: npm dist-tag add "$release" latest
-              env:
-                  NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-                  release: ${{ steps.npm-publish.outputs.id }}
@@ -1,52 +0,0 @@
-name: Release Process
-on:
-    release:
-        types: [published]
-concurrency: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-    jsdoc:
-        name: Publish Documentation
-        runs-on: ubuntu-latest
-        steps:
-            - name: 🧮 Checkout code
-              uses: actions/checkout@v4
-
-            - name: 🧮 Checkout gh-pages
-              uses: actions/checkout@v4
-              with:
-                  ref: gh-pages
-                  path: _docs
-
-            - name: 🔧 Yarn cache
-              uses: actions/setup-node@v3
-              with:
-                  cache: "yarn"
-
-            - name: 🔨 Install dependencies
-              run: "yarn install --frozen-lockfile"
-
-            - name: 🔨 Install symlinks
-              run: |
-                  sudo apt-get update
-                  sudo apt-get install -y symlinks
-
-            - name: 📖 Generate docs
-              run: |
-                  yarn tpv purge --yes --out _docs --stale --major 10
-                  yarn gendoc
-                  symlinks -rc _docs
-
-            - name: 🚀 Deploy
-              run: |
-                  git config --global user.email "releases@riot.im"
-                  git config --global user.name "RiotRobot"
-                  git add . --all
-                  git commit -m "Update docs"
-                  git push
-              working-directory: _docs
-
-    npm:
-        name: Publish
-        uses: matrix-org/matrix-js-sdk/.github/workflows/release-npm.yml@develop
-        secrets:
-            NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
@@ -1,52 +0,0 @@
-# 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
-        inputs:
-            extra_args:
-                type: string
-                required: false
-                description: "Extra args to pass to SonarCloud"
-jobs:
-    sonarqube:
-        runs-on: ubuntu-latest
-        if: github.event.workflow_run.conclusion == 'success'
-        steps:
-            # We create the status here and then update it to success/failure in the `report` stage
-            # This provides an easy link to this workflow_run from the PR before Cypress is done.
-            - uses: Sibz/github-status-action@faaa4d96fecf273bd762985e0e7f9f933c774918 # v1
-              with:
-                  authToken: ${{ secrets.GITHUB_TOKEN }}
-                  state: pending
-                  context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
-                  sha: ${{ github.event.workflow_run.head_sha }}
-                  target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}
-
-            - name: "🩻 SonarCloud Scan"
-              id: sonarcloud
-              uses: matrix-org/sonarcloud-workflow-action@v2.5
-              # workflow_run fails report against the develop commit always, we don't want that for PRs
-              continue-on-error: ${{ github.event.workflow_run.head_branch != 'develop' }}
-              with:
-                  repository: ${{ github.event.workflow_run.head_repository.full_name }}
-                  is_pr: ${{ github.event.workflow_run.event == 'pull_request' }}
-                  version_cmd: "cat package.json | jq -r .version"
-                  branch: ${{ github.event.workflow_run.head_branch }}
-                  revision: ${{ github.event.workflow_run.head_sha }}
-                  token: ${{ secrets.SONAR_TOKEN }}
-                  coverage_run_id: ${{ github.event.workflow_run.id }}
-                  coverage_workflow_name: tests.yml
-                  coverage_extract_path: coverage
-                  extra_args: ${{ inputs.extra_args }}
-
-            - uses: Sibz/github-status-action@faaa4d96fecf273bd762985e0e7f9f933c774918 # 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 }}
@@ -1,45 +0,0 @@
-name: SonarQube
-on:
-    workflow_run:
-        workflows: ["Tests"]
-        types:
-            - completed
-concurrency:
-    group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch }}
-    cancel-in-progress: true
-jobs:
-    # This is a workaround for https://github.com/SonarSource/SonarJS/issues/578
-    prepare:
-        name: Prepare
-        if: github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.event != 'merge_group'
-        runs-on: ubuntu-latest
-        outputs:
-            reportPaths: ${{ steps.extra_args.outputs.reportPaths }}
-            testExecutionReportPaths: ${{ steps.extra_args.outputs.testExecutionReportPaths }}
-        steps:
-            # There's a 'download artifact' action, but it hasn't been updated for the workflow_run action
-            # (https://github.com/actions/download-artifact/issues/60) so instead we get this mess:
-            - name: 📥 Download artifact
-              uses: dawidd6/action-download-artifact@246dbf436b23d7c49e21a7ab8204ca9ecd1fe615 # v2
-              with:
-                  workflow: tests.yaml
-                  run_id: ${{ github.event.workflow_run.id }}
-                  name: coverage
-                  path: coverage
-
-            - id: extra_args
-              run: |
-                  coverage=$(find coverage -type f -name '*lcov.info' | tr '\n' ',' | sed 's/,$//g')
-                  echo "reportPaths=$coverage" >> $GITHUB_OUTPUT
-                  reports=$(find coverage -type f -name 'jest-sonar-report*.xml' | tr '\n' ',' | sed 's/,$//g')
-                  echo "testExecutionReportPaths=$reports" >> $GITHUB_OUTPUT
-
-    sonarqube:
-        name: 🩻 SonarQube
-        if: github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.event != 'merge_group'
-        needs: prepare
-        uses: matrix-org/matrix-js-sdk/.github/workflows/sonarcloud.yml@develop
-        secrets:
-            SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-        with:
-            extra_args: -Dsonar.javascript.lcov.reportPaths=${{ needs.prepare.outputs.reportPaths }} -Dsonar.testExecutionReportPaths=${{ needs.prepare.outputs.testExecutionReportPaths }}
@@ -1,83 +0,0 @@
-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@v3
-              with:
-                  cache: "yarn"
-
-            - 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@v3
-              with:
-                  cache: "yarn"
-
-            - name: Install Deps
-              run: "yarn install"
-
-            - name: Run Linter
-              run: "yarn run lint:js"
-
-    docs:
-        name: "JSDoc Checker"
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v4
-
-            - uses: actions/setup-node@v3
-              with:
-                  cache: "yarn"
-
-            - name: Install Deps
-              run: "yarn install"
-
-            - name: Generate Docs
-              run: "yarn run gendoc --treatWarningsAsErrors"
-
-            # Upload artifact duplicates symlink contents so we do this to save 75% space
-            - name: Flatten symlink and write _redirects
-              run: |
-                  find _docs -mindepth 1 -maxdepth 1 ! -type f ! -name stable -printf '/%f/* /stable/:splat\n' > _docs/_redirects
-                  find _docs -mindepth 1 -maxdepth 1 -type l -delete
-                  find _docs -mindepth 1 -maxdepth 1 -type d -execdir mv {} stable \; -quit
-
-            - name: Upload Artifact
-              uses: actions/upload-artifact@v3
-              with:
-                  name: docs
-                  path: _docs
-                  # We'll only use this in a workflow_run, then we're done with it
-                  retention-days: 1
@@ -1,98 +0,0 @@
-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 }})"
-        runs-on: ubuntu-latest
-        timeout-minutes: 10
-        strategy:
-            matrix:
-                specs: [browserify, integ, unit]
-                node: [18, latest]
-        steps:
-            - name: Checkout code
-              uses: actions/checkout@v4
-
-            - name: Setup Node
-              uses: actions/setup-node@v3
-              with:
-                  cache: "yarn"
-                  node-version: ${{ matrix.node }}
-
-            - name: Install dependencies
-              run: "yarn install"
-
-            - name: Build
-              if: matrix.specs == 'browserify'
-              run: "yarn build"
-
-            - name: Get number of CPU cores
-              id: cpu-cores
-              uses: SimenB/github-actions-cpu-cores@410541432439795d30db6501fb1d8178eb41e502 # v1
-
-            - 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/${{ matrix.node }}-${{ matrix.specs }}.lcov.info
-
-            - name: Upload Artifact
-              if: env.ENABLE_COVERAGE == 'true'
-              uses: actions/upload-artifact@v3
-              with:
-                  name: coverage
-                  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 }}
-
-    # 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@faaa4d96fecf273bd762985e0e7f9f933c774918 # 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
@@ -1,38 +0,0 @@
-name: Upgrade Dependencies
-on:
-    workflow_dispatch: {}
-    workflow_call:
-        secrets:
-            ELEMENT_BOT_TOKEN:
-                required: true
-jobs:
-    upgrade:
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v4
-
-            - uses: actions/setup-node@v3
-              with:
-                  cache: "yarn"
-
-            - name: Upgrade
-              run: yarn upgrade && yarn install
-
-            - name: Create Pull Request
-              id: cpr
-              uses: peter-evans/create-pull-request@153407881ec5c347639a548ade7d8ad1d6740e38 # v5
-              with:
-                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-                  branch: actions/upgrade-deps
-                  delete-branch: true
-                  title: Upgrade dependencies
-                  labels: |
-                      Dependencies
-                      T-Task
-
-            - name: Enable automerge
-              run: gh pr merge --merge --auto "$PR_NUMBER"
-              if: steps.cpr.outputs.pull-request-operation == 'created'
-              env:
-                  GH_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}
-                  PR_NUMBER: ${{ steps.cpr.outputs.pull-request-number }}
@@ -1,22 +1,17 @@
-/_docs
-.DS_Store
+/.jsdocbuild
+/.jsdoc

 node_modules
-/.npmrc
-/*.log
-package-lock.json
 .lock-wscript
 build/Release
 coverage
 lib-cov
 out
+reports
 /dist
 /lib
+/specbuild

-# version file and tarball created by `npm pack` / `yarn pack`
+# version file and tarball created by 'npm pack'
 /git-revision.txt
 /matrix-js-sdk-*.tgz
-
-.vscode
-.vscode/
-.idea/
@@ -0,0 +1,2 @@
+instrumentation:
+  compact: false
@@ -1,29 +0,0 @@
-/_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
-
-# This file is also autogenerated
-/spec/test-utils/test-data/index.ts
@@ -1 +0,0 @@
-module.exports = require("eslint-plugin-matrix-org/.prettierrc.js");
@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+    - node # Latest stable version of nodejs.
+script:
+    - ./travis.sh
@@ -1,3 +0,0 @@
-# Contributing code to matrix-js-sdk
-
-matrix-js-sdk follows the same pattern as https://github.com/vector-im/element-web/blob/develop/CONTRIBUTING.md
@@ -0,0 +1,115 @@
+Contributing code to matrix-js-sdk
+==================================
+
+Everyone is welcome to contribute code to matrix-js-sdk, provided that they are
+willing to license their contributions under the same license as the project
+itself. We follow a simple 'inbound=outbound' model for contributions: the act
+of submitting an 'inbound' contribution means that the contributor agrees to
+license the code under the same terms as the project's overall 'outbound'
+license - in this case, Apache Software License v2 (see `<LICENSE>`_).
+
+How to contribute
+~~~~~~~~~~~~~~~~~
+
+The preferred and easiest way to contribute changes to the project is to fork
+it on github, and then create a pull request to ask us to pull your changes
+into our repo (https://help.github.com/articles/using-pull-requests/)
+
+**The single biggest thing you need to know is: please base your changes on
+the develop branch - /not/ master.**
+
+We use the master branch to track the most recent release, so that folks who
+blindly clone the repo and automatically check out master get something that
+works. Develop is the unstable branch where all the development actually
+happens: the workflow is that contributors should fork the develop branch to
+make a 'feature' branch for a particular contribution, and then make a pull
+request to merge this back into the matrix.org 'official' develop branch. We
+use github's pull request workflow to review the contribution, and either ask
+you to make any refinements needed or merge it and make them ourselves. The
+changes will then land on master when we next do a release.
+
+We use Travis for continuous integration, and all pull requests get
+automatically tested by Travis: 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 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>
+
+...using your real name; unfortunately pseudonyms and anonymous contributions
+can't be accepted. Git makes this trivial - just use the -s flag when you do
+``git commit``, having first set ``user.name`` and ``user.email`` git configs
+(which you should have done anyway :)
@@ -1,176 +1,100 @@
-[![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)
+Matrix Javascript SDK
+=====================
+[![Build Status](http://matrix.org/jenkins/buildStatus/icon?job=JavascriptSDK)](http://matrix.org/jenkins/job/JavascriptSDK/)

-# Matrix JavaScript SDK
+This is the [Matrix](https://matrix.org) Client-Server v1/v2 alpha SDK for
+JavaScript. This SDK can be run in a browser or in Node.js.

-This is the [Matrix](https://matrix.org) Client-Server SDK for JavaScript and TypeScript. This SDK can be run in a
-browser or in Node.js.
+Quickstart
+==========

-#### Minimum Matrix server version: v1.1
-
-The Matrix specification is constantly evolving - while this SDK aims for maximum backwards compatibility, it only
-guarantees that a feature will be supported for at least 4 spec releases. For example, if a feature the js-sdk supports
-is removed in v1.4 then the feature is _eligible_ for removal from the SDK when v1.8 is released. This SDK has no
-guarantee on implementing all features of any particular spec release, currently. This can mean that the SDK will call
-endpoints from before Matrix 1.1, for example.
-
-# Quickstart
-
-## In a browser
-
-### Note, the browserify build has been deprecated. Please use a bundler like webpack or vite instead.
-
-Download the browser version from
+In a browser
+------------
+Download either the full or minified version from
 https://github.com/matrix-org/matrix-js-sdk/releases/latest and add that as a
-`<script>` to your page. There will be a global variable `matrixcs`
-attached to `window` through which you can access the SDK. See below for how to
+``<script>`` to your page. There will be a global variable ``matrixcs``
+attached to ``window`` through which you can access the SDK. See below for how to
 include libolm to enable end-to-end-encryption.

-The browser bundle supports recent versions of browsers. Typically this is ES2015
-or `> 0.5%, last 2 versions, Firefox ESR, not dead` if using
-[browserlists](https://github.com/browserslist/browserslist).
-
 Please check [the working browser example](examples/browser) for more information.

-## In Node.js
+In Node.js
+----------

-Ensure you have the latest LTS version of Node.js installed.
-This library relies on `fetch` which is available in Node from v18.0.0 - it should work fine also with polyfills.
-If you wish to use a ponyfill or adapter of some sort then pass it as `fetchFn` to the MatrixClient constructor options.
-
-Using `yarn` instead of `npm` is recommended. Please see the Yarn [install guide](https://classic.yarnpkg.com/en/docs/install)
-if you do not have it already.
-
-`yarn add matrix-js-sdk`
+``npm install matrix-js-sdk``

 ```javascript
-import * as sdk from "matrix-js-sdk";
-const client = sdk.createClient({ baseUrl: "https://matrix.org" });
-client.publicRooms(function (err, data) {
+  var sdk = require("matrix-js-sdk");
+  var client = sdk.createClient("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
 [the Node.js terminal app](examples/node) for a more complex example.

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

-To start the client:
-
-```javascript
-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") {
-        console.log("prepared");
-    } else {
-        console.log(state);
-        process.exit(1);
-    }
-});
-```
-
-To send a message:
-
-```javascript
-const content = {
-    body: "message text",
-    msgtype: "m.text",
-};
-client.sendEvent("roomId", "m.room.message", content, "", (err, res) => {
-    console.log(err);
-});
-```
-
-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);
-});
-```
-
-By default, the `matrix-js-sdk` client uses the `MemoryStore` to store events as they are received. For example to iterate through the currently stored timeline for a room:
-
-```javascript
-Object.keys(client.store.rooms).forEach((roomId) => {
-    client.getRoom(roomId).timeline.forEach((t) => {
-        console.log(t.event);
-    });
-});
-```
-
-## What does this SDK do?
+What does this SDK do?
+----------------------

 This SDK provides a full object model around the Matrix Client-Server API and emits
 events for incoming data and state changes. Aside from wrapping the HTTP API, it:
-
-   Handles syncing (via `/initialSync` and `/events`)
-   Handles the generation of "friendly" room and member names.
-   Handles historical `RoomMember` information (e.g. display names).
-   Manages room member state across multiple events (e.g. it handles typing, power
-    levels and membership changes).
-   Exposes high-level objects like `Rooms`, `RoomState`, `RoomMembers` and `Users`
-    which can be listened to for things like name changes, new messages, membership
-    changes, presence changes, and more.
-   Handle "local echo" of messages sent using the SDK. This means that messages
-    that have just been sent will appear in the timeline as 'sending', until it
-    completes. This is beneficial because it prevents there being a gap between
-    hitting the send button and having the "remote echo" arrive.
-   Mark messages which failed to send as not sent.
-   Automatically retry requests to send messages due to network errors.
-   Automatically retry requests to send messages due to rate limiting errors.
-   Handle queueing of messages.
-   Handles pagination.
-   Handle assigning push actions for events.
-   Handles room initial sync on accepting invites.
-   Handles WebRTC calling.
+ - Handles syncing (via `/initialSync` and `/events`)
+ - Handles the generation of "friendly" room and member names.
+ - Handles historical `RoomMember` information (e.g. display names).
+ - Manages room member state across multiple events (e.g. it handles typing, power
+   levels and membership changes).
+ - Exposes high-level objects like `Rooms`, `RoomState`, `RoomMembers` and `Users`
+   which can be listened to for things like name changes, new messages, membership
+   changes, presence changes, and more.
+ - Handle "local echo" of messages sent using the SDK. This means that messages
+   that have just been sent will appear in the timeline as 'sending', until it
+   completes. This is beneficial because it prevents there being a gap between
+   hitting the send button and having the "remote echo" arrive.
+ - Mark messages which failed to send as not sent.
+ - Automatically retry requests to send messages due to network errors.
+ - Automatically retry requests to send messages due to rate limiting errors.
+ - Handle queueing of messages.
+ - Handles pagination.
+ - Handle assigning push actions for events.
+ - Handles room initial sync on accepting invites.
+ - Handles WebRTC calling.

 Later versions of the SDK will:
+ - Expose a `RoomSummary` which would be suitable for a recents page.
+ - Provide different pluggable storage layers (e.g. local storage, database-backed)

-   Expose a `RoomSummary` which would be suitable for a recents page.
-   Provide different pluggable storage layers (e.g. local storage, database-backed)
+Usage
+=====

-# Usage

-## Conventions
+Conventions
+-----------

 ### Emitted events

-The SDK will emit events using an `EventEmitter`. It also
-emits object models (e.g. `Rooms`, `RoomMembers`) when they
+The SDK will emit events using an ``EventEmitter``. It also
+emits object models (e.g. ``Rooms``, ``RoomMembers``) when they
 are updated.

 ```javascript
-// Listen for low-level MatrixEvents
-client.on("event", function (event) {
+  // Listen for low-level MatrixEvents
+  client.on("event", function(event) {
    console.log(event.getType());
-});
+  });

-// Listen for typing changes
-client.on("RoomMember.typing", function (event, member) {
+  // Listen for typing changes
+  client.on("RoomMember.typing", function(event, member) {
    if (member.typing) {
-        console.log(member.name + " is typing...");
-    } else {
-        console.log(member.name + " stopped typing.");
+      console.log(member.name + " is 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
@@ -182,82 +106,80 @@ which will be fulfilled in the future.
 The typical usage is something like:

 ```javascript
-  matrixClient.someMethod(arg1, arg2).then(function(result) {
+  matrixClient.someMethod(arg1, arg2).done(function(result) {
    ...
  });
 ```

-Alternatively, if you have a Node.js-style `callback(err, result)` function,
+Alternatively, if you have a Node.js-style ``callback(err, result)`` function,
 you can pass the result of the promise into it with something like:

 ```javascript
-matrixClient.someMethod(arg1, arg2).nodeify(callback);
+  matrixClient.someMethod(arg1, arg2).nodeify(callback);
 ```

-The main thing to note is that it is problematic to discard the result of a
-promise-returning function, as that will cause exceptions to go unobserved.
+The main thing to note is that it is an error to discard the result of a
+promise-returning function, as that will cause exceptions to go unobserved. If
+you have nothing better to do with the result, just call ``.done()`` on it. See
+http://documentup.com/kriskowal/q/#the-end for more information.

 Methods which return a promise show this in their documentation.

-Many methods in the SDK support _both_ Node.js-style callbacks _and_ Promises,
-via an optional `callback` argument. The callback support is now deprecated:
-new methods do not include a `callback` argument, and in the future it may be
+Many methods in the SDK support *both* Node.js-style callbacks *and* Promises,
+via an optional ``callback`` argument. The callback support is now deprecated:
+new methods do not include a ``callback`` argument, and in the future it may be
 removed from existing methods.

-## Examples
-
+Examples
+--------
 This section provides some useful code snippets which demonstrate the
 core functionality of the SDK. These examples assume the SDK is setup like this:

 ```javascript
-import * as sdk from "matrix-js-sdk";
-const myUserId = "@example:localhost";
-const myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
-const matrixClient = sdk.createClient({
-    baseUrl: "http://localhost:8008",
-    accessToken: myAccessToken,
-    userId: myUserId,
-});
+   var sdk = require("matrix-js-sdk");
+   var myUserId = "@example:localhost";
+   var myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
+   var matrixClient = sdk.createClient({
+       baseUrl: "http://localhost:8008",
+       accessToken: myAccessToken,
+       userId: myUserId
+   });
 ```

 ### Automatically join rooms when invited

 ```javascript
-matrixClient.on("RoomMember.membership", function (event, member) {
-    if (member.membership === "invite" && member.userId === myUserId) {
-        matrixClient.joinRoom(member.roomId).then(function () {
-            console.log("Auto-joined %s", member.roomId);
-        });
-    }
-});
+   matrixClient.on("RoomMember.membership", function(event, member) {
+       if (member.membership === "invite" && member.userId === myUserId) {
+           matrixClient.joinRoom(member.roomId).done(function() {
+               console.log("Auto-joined %s", member.roomId);
+           });
+       }
+   });

-matrixClient.startClient();
+   matrixClient.startClient();
 ```

 ### Print out messages for all rooms

 ```javascript
-matrixClient.on("Room.timeline", function (event, room, toStartOfTimeline) {
-    if (toStartOfTimeline) {
-        return; // don't print paginated results
-    }
-    if (event.getType() !== "m.room.message") {
-        return; // only print messages
-    }
-    console.log(
-        // the room name will update with m.room.name events automatically
-        "(%s) %s :: %s",
-        room.name,
-        event.getSender(),
-        event.getContent().body,
-    );
-});
+   matrixClient.on("Room.timeline", function(event, room, toStartOfTimeline) {
+       if (toStartOfTimeline) {
+           return; // don't print paginated results
+       }
+       if (event.getType() !== "m.room.message") {
+           return; // only print messages
+       }
+       console.log(
+           // the room name will update with m.room.name events automatically
+           "(%s) %s :: %s", room.name, event.getSender(), event.getContent().body
+       );
+   });

-matrixClient.startClient();
+   matrixClient.startClient();
 ```

 Output:
-
 ```
  (My Room) @megan:localhost :: Hello world
  (My Room) @megan:localhost :: how are you?
@@ -269,24 +191,27 @@ Output:
 ### Print out membership lists whenever they are changed

 ```javascript
-matrixClient.on("RoomState.members", function (event, state, member) {
-    const room = matrixClient.getRoom(state.roomId);
-    if (!room) {
-        return;
-    }
-    const memberList = state.getMembers();
-    console.log(room.name);
-    console.log(Array(room.name.length + 1).join("=")); // underline
-    for (var i = 0; i < memberList.length; i++) {
-        console.log("(%s) %s", memberList[i].membership, memberList[i].name);
-    }
-});
+   matrixClient.on("RoomState.members", function(event, state, member) {
+       var room = matrixClient.getRoom(state.roomId);
+       if (!room) {
+           return;
+       }
+       var 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
  =======
@@ -296,34 +221,36 @@ 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 [Typedoc](https://typedoc.org/guides/doccomments) doc comments. You can manually build and
+This SDK uses JSDoc3 style comments. You can manually build and
 host the API reference from the source files like this:

 ```
-  $ yarn gendoc
-  $ cd _docs
-  $ python -m http.server 8005
+  $ npm run gendoc
+  $ cd .jsdoc
+  $ python -m SimpleHTTPServer 8005
 ```

-Then visit `http://localhost:8005` to see the API docs.
+Then visit ``http://localhost:8005`` to see the API docs.

-# End-to-end encryption support
+End-to-end encryption support
+=============================

 The SDK supports end-to-end encryption via the Olm and Megolm protocols, using
-[libolm](https://gitlab.matrix.org/matrix-org/olm). It is left up to the
-application to make libolm available, via the `Olm` global.
+[libolm](http://matrix.org/git/olm). It is left up to the application to make
+libolm available, via the ``Olm`` global.

-It is also necessary to call `await matrixClient.initCrypto()` after creating a new
-`MatrixClient` (but **before** calling `matrixClient.startClient()`) to
+It is also necessry to call ``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
@@ -335,51 +262,51 @@ specification.

 To provide the Olm library in a browser application:

-   download the transpiled libolm (from https://packages.matrix.org/npm/olm/).
-   load `olm.js` as a `<script>` _before_ `browser-matrix.js`.
-
+ * download the transpiled libolm (from https://matrix.org/packages/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
-    https://packages.matrix.org/npm/olm/)
-   `global.Olm = require('olm');` _before_ loading `matrix-js-sdk`.
+ * ``npm install https://matrix.org/packages/npm/olm/olm-2.2.2.tgz``
+   (replace the URL with the latest version you want to use from
+    https://matrix.org/packages/npm/olm/)
+ * ``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
-as an optional dependency.
+If you want to package Olm as dependency for your node.js application, you
+can use ``npm install https://matrix.org/packages/npm/olm/olm-2.2.2.tgz 
+--save-optional`` (if your application also works without e2e crypto enabled)
+or ``--save`` (if it doesn't) to do so.

-# Contributing

-_This section is for people who want to modify the SDK. If you just
-want to use this SDK, skip this section._
+Contributing
+============
+*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
+ $ npm install
 ```

-## Building
+Building
+--------

 To build a browser version from scratch when developing::
-
 ```
- $ yarn build
+ $ npm run build
 ```

-To run tests (Jest):
-
+To constantly do builds when files are modified (using ``watchify``)::
 ```
- $ yarn test
+ $ npm run watch
 ```

-> **Note**
-> The `sync-browserify.spec.ts` requires a browser build (`yarn build`) in order to pass
+To run tests (Jasmine)::
+```
+ $ npm test
+```

 To run linting:
-
 ```
- $ yarn lint
+ $ npm run lint
 ```
@@ -0,0 +1,23 @@
+var matrixcs = require("./lib/matrix");
+matrixcs.request(require("browser-request"));
+
+// just *accessing* indexedDB throws an exception in firefox with
+// indexeddb disabled.
+var indexedDB;
+try {
+    indexedDB = global.indexedDB;
+} catch(e) {}
+
+// if our browser (appears to) support indexeddb, use an indexeddb crypto store.
+if (indexedDB) {
+    matrixcs.setCryptoStoreFactory(
+        function() {
+            return new matrixcs.IndexedDBCryptoStore(
+                indexedDB, "matrix-js-sdk:crypto"
+            );
+        }
+    );
+}
+
+module.exports = matrixcs; // keep export for browserify package deps
+global.matrixcs = matrixcs;
@@ -1,70 +0,0 @@
-# Browser Storage Notes
-
-## Overview
-
-Browsers examined: Firefox 67, Chrome 75
-
-The examination below applies to the default, non-persistent storage policy.
-
-## Quota Measurement
-
-Browsers appear to enforce and measure the quota in terms of space on disk, not
-data stored, so you may be able to store more data than the simple sum of all
-input data depending on how compressible your data is.
-
-## Quota Limit
-
-Specs and documentation suggest we should consistently receive
-`QuotaExceededError` when we're near space limits, but the reality is a bit
-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
-
-## Cache Eviction
-
-While the Storage Standard says all storage for an origin group should be
-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
-
-## Persistent Storage
-
-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
-
-## 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
@@ -1,10 +1,9 @@
 To try it out, **you must build the SDK first** and then host this folder:

 ```
- $ yarn install
- $ yarn build
+ $ npm run build
 $ cd examples/browser
- $ python -m http.server 8003
+ $ python -m SimpleHTTPServer 8003
 ```

-Then visit `http://localhost:8003`.
+Then visit ``http://localhost:8003``.
@@ -1,7 +1,12 @@
+"use strict";
 console.log("Loading browser sdk");

-var client = matrixcs.createClient({ baseUrl: "https://matrix.org" });
-client.publicRooms().then(function (data) {
+var client = matrixcs.createClient("http://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");
@@ -1,17 +1,16 @@
-<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>
+<head>
+<title>Test</title>
+<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>
@@ -1,2 +0,0 @@
-olm.js
-olm.wasm
@@ -1 +0,0 @@
-../../../dist/browser-matrix.js
@@ -1,60 +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>
@@ -1,105 +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",
-        });
-    };
-}
@@ -1,5 +1,6 @@
 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:

 ```
@@ -23,7 +24,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
@@ -1,3 +1,5 @@
+"use strict";
+
 var myUserId = "@example:localhost";
 var myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
 var sdk = require("matrix-js-sdk");
@@ -5,7 +7,7 @@ var clc = require("cli-color");
 var matrixClient = sdk.createClient({
    baseUrl: "http://localhost:8008",
    accessToken: myAccessToken,
-    userId: myUserId,
+    userId: myUserId
 });

 // Data structures
@@ -14,15 +16,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,11 +39,14 @@ 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++) {
@@ -51,105 +56,97 @@ 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).done(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).done(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).done(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
+            }).done(function(url) {
+                var content = {
+                    msgtype: "m.file",
+                    body: filename,
+                    url: JSON.parse(url).content_uri
+                };
+                matrixClient.sendMessage(viewingRoom.roomId, content);
+            });
+        }
+        else {
+            matrixClient.sendTextMessage(viewingRoom.roomId, line).finally(function() {
                printMessages();
                rl.prompt();
            });
            // print local echo immediately
            printMessages();
        }
-    } else {
+    }
+    else {
        if (line.indexOf("/join ") === 0) {
            var roomIndex = line.split(" ")[1];
            viewingRoom = roomList[roomIndex];
            if (viewingRoom.getMember(myUserId).membership === "invite") {
                // join the room first
-                matrixClient.joinRoom(viewingRoom.roomId).then(
-                    function (room) {
-                        setRoomList();
-                        viewingRoom = room;
-                        printMessages();
-                        rl.prompt();
-                    },
-                    function (err) {
-                        print("/join Error: %s", err);
-                    },
-                );
-            } else {
+                matrixClient.joinRoom(viewingRoom.roomId).done(function(room) {
+                    setRoomList();
+                    viewingRoom = room;
+                    printMessages();
+                    rl.prompt();
+                }, function(err) {
+                    print("/join Error: %s", err);
+                });
+            }
+            else {
                printMessages();
            }
-        }
+        } 
    }
    rl.prompt();
 });
 // ==== 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();
@@ -158,7 +155,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
    }
@@ -170,19 +167,20 @@ 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;
@@ -193,27 +191,27 @@ 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) {
-            fmt = fmts[myMembership];
+        var me = roomList[i].getMember(myUserId);
+        if (me) {
+            fmt = fmts[me.membership];
        }
        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
        );
    }
 }
@@ -234,12 +232,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() {
@@ -256,14 +254,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;
        }
@@ -272,58 +270,61 @@ 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
        );
    });
 }

 function printRoomInfo(room) {
-    var eventMap = room.currentState.events;
+    var eventDict = room.currentState.events;
    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.
-        var eventEventMap = eventMap.get(eventType);
-        eventEventMap.keys().forEach(function (stateKey) {
-            var typeAndKey = eventType + (stateKey.length > 0 ? "(" + stateKey + ")" : "");
+    Object.keys(eventDict).forEach(function(eventType) {
+        if (eventType === "m.room.member") { return; } // use /members instead.
+        Object.keys(eventDict[eventType]).forEach(function(stateKey) {
+            var typeAndKey = eventType + (
+                stateKey.length > 0 ? "("+stateKey+")" : ""
+            );
            var typeStr = fixWidth(typeAndKey, eTypeHeader.length);
-            var event = eventEventMap.get(stateKey);
+            var event = eventDict[eventType][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,7 +332,8 @@ 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;
        }
@@ -340,58 +342,69 @@ function printLine(event) {

    var maxNameWidth = 15;
    if (name.length > maxNameWidth) {
-        name = name.slice(0, maxNameWidth - 1) + "\u2026";
+        name = name.substr(0, maxNameWidth-1) + "\u2026";
    }

    if (event.getType() === "m.room.message") {
        body = event.getContent().body;
-    } else if (event.isState()) {
+    }
+    else if (event.isState()) {
        var stateName = event.getType();
        if (event.getStateKey().length > 0) {
-            stateName += " (" + event.getStateKey() + ")";
+            stateName += " ("+event.getStateKey()+")";
        }
-        body = "[State: " + stateName + " updated to: " + JSON.stringify(event.getContent()) + "]";
+        body = (
+            "[State: "+stateName+" updated to: "+JSON.stringify(event.getContent())+"]"
+        );
        separator = "---";
        fmt = clc.xterm(249).italic;
-    } else {
+    }
+    else {
        // random message event
-        body = "[Message: " + event.getType() + " Content: " + JSON.stringify(event.getContent()) + "]";
+        body = (
+            "[Message: "+event.getType()+" Content: "+JSON.stringify(event.getContent())+"]"
+        );
        separator = "---";
        fmt = clc.xterm(249).italic;
    }
    if (fmt) {
-        print("[%s] %s %s %s", time, name, separator, body, fmt);
-    } else {
+        print(
+            "[%s] %s %s %s", time, name, separator, body, fmt
+        );
+    }
+    else {
        print("[%s] %s %s %s", time, name, separator, body);
    }
 }

 function print(str, formatter) {
-    if (typeof arguments[arguments.length - 1] === "function") {
+    if (typeof arguments[arguments.length-1] === "function") {
        // last arg is the formatter so get rid of it and use it on each
        // param passed in but not the template string.
        var newArgs = [];
        var i = 0;
-        for (i = 0; i < arguments.length - 1; i++) {
+        for (i=0; i<arguments.length-1; i++) {
            newArgs.push(arguments[i]);
        }
-        var fmt = arguments[arguments.length - 1];
-        for (i = 0; i < newArgs.length; i++) {
+        var fmt = arguments[arguments.length-1];
+        for (i=0; i<newArgs.length; i++) {
            newArgs[i] = fmt(newArgs[i]);
        }
        console.log.apply(console.log, newArgs);
-    } else {
+    }
+    else {
        console.log.apply(console.log, arguments);
    }
 }

 function fixWidth(str, len) {
    if (str.length > len) {
-        return str.substring(0, len - 2) + "\u2026";
-    } else if (str.length < len) {
+        return str.substr(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.
@@ -1,14 +1,14 @@
 {
-    "name": "example-app",
-    "version": "0.0.0",
-    "description": "",
-    "main": "app.js",
-    "scripts": {
-        "preinstall": "npm install ../.."
-    },
-    "author": "",
-    "license": "Apache 2.0",
-    "dependencies": {
-        "cli-color": "^1.0.0"
-    }
+  "name": "example-app",
+  "version": "0.0.0",
+  "description": "",
+  "main": "app.js",
+  "scripts": {
+    "preinstall": "npm install ../.."
+  },
+  "author": "",
+  "license": "Apache 2.0",
+  "dependencies": {
+    "cli-color": "^1.0.0"
+  }
 }
@@ -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``.
@@ -1,17 +1,17 @@
+"use strict";
 console.log("Loading browser sdk");
-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 BASE_URL = "https://matrix.org";
+var TOKEN = "accesstokengoeshere";
+var USER_ID = "@username:localhost";
+var ROOM_ID = "!room:id";

-const client = matrixcs.createClient({
+
+var client = matrixcs.createClient({
    baseUrl: BASE_URL,
    accessToken: TOKEN,
-    userId: USER_ID,
-    deviceId: DEVICE_ID,
+    userId: USER_ID
 });
-let call;
+var call;

 function disableButtons(place, answer, hangup) {
    document.getElementById("hangup").disabled = hangup;
@@ -20,82 +20,65 @@ function disableButtons(place, answer, hangup) {
 }

 function addListeners(call) {
-    let lastError = "";
-    call.on("hangup", function () {
+    var 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) {
-        const localFeed = feeds.find((feed) => feed.isLocal());
-        const remoteFeed = feeds.find((feed) => !feed.isLocal());
-
-        const remoteElement = document.getElementById("remote");
-        const localElement = document.getElementById("local");
-
-        if (remoteFeed) {
-            remoteElement.srcObject = remoteFeed.stream;
-            remoteElement.play();
-        }
-        if (localFeed) {
-            localElement.muted = true;
-            localElement.srcObject = localFeed.stream;
-            localElement.play();
-        }
-    });
 }

-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();
+        call.placeVideoCall(
+            document.getElementById("remote"),
+            document.getElementById("local")
+        );
        document.getElementById("result").innerHTML = "<p>Placed call.</p>";
        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();
@@ -103,7 +86,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>";
@@ -1,32 +1,26 @@
 <html>
-    <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>
+<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">
+        <div id="videoContainer">
+            <video id="remote"></video>
        </div>
-    </body>
+    </div>
+    <div id="videoBackground">
+        <div id="videoContainer">
+            <video id="local"></video>
+        </div>
+    </div>
+</body>
 </html>
-
-<style>
-    .video-background {
-        height: 500px;
-        margin: 10px;
-    }
-
-    .video-element {
-        height: 100%;
-    }
-</style>
@@ -21,4 +21,4 @@ export PATH="$rootdir/node_modules/.bin:$PATH"

 # now run our checks
 cd "$tmpdir"
-yarn lint
+npm run lint
@@ -0,0 +1,6 @@
+var matrixcs = require("./lib/matrix");
+matrixcs.request(require("request"));
+module.exports = matrixcs;
+
+var utils = require("./lib/utils");
+utils.runPolyfills();
@@ -0,0 +1,34 @@
+#!/bin/bash -l
+
+set -x
+
+export NVM_DIR="$HOME/.nvm"
+[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
+
+nvm use 6 || exit $?
+npm install || exit $?
+
+RC=0
+
+function fail {
+    echo $@ >&2
+    RC=1
+}
+
+# don't use last time's test reports
+rm -rf reports coverage || exit $?
+
+npm test || fail "npm test finished with return code $?"
+
+npm run -s lint -- -f checkstyle > eslint.xml ||
+    fail "eslint finished with return code $?"
+
+# delete the old tarball, if it exists
+rm -f matrix-js-sdk-*.tgz
+
+npm pack ||
+    fail "npm pack finished with return code $?"
+
+npm run gendoc || fail "JSDoc failed with code $?"
+
+exit $RC
@@ -1,47 +0,0 @@
-/* Copyright 2023 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import 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;
@@ -1,161 +1,88 @@
 {
-    "name": "matrix-js-sdk",
-    "version": "28.2.0",
-    "description": "Matrix Client-Server SDK for Javascript",
-    "engines": {
-        "node": ">=18.0.0"
-    },
-    "scripts": {
-        "prepublishOnly": "yarn build",
-        "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
-        "dist": "echo 'This is for the release script so it can make assets (browser bundle).' && yarn build",
-        "clean": "rimraf lib dist",
-        "build": "yarn build:dev && yarn build:compile-browser && yarn build:minify-browser",
-        "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
-        "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
-        "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
-        "build:compile-browser": "mkdir dist && BROWSERIFYSWAP_ENV='no-rust-crypto' browserify -d src/browser-index.ts -p [ tsify -p ./tsconfig-build.json ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
-        "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
-        "gendoc": "typedoc",
-        "lint": "yarn lint:types && yarn lint:js",
-        "lint:js": "eslint --max-warnings 0 src spec && prettier --check .",
-        "lint:js-fix": "prettier --loglevel=warn --write . && eslint --fix src spec",
-        "lint:types": "tsc --noEmit",
-        "test": "jest",
-        "test:watch": "jest --watch",
-        "coverage": "yarn test --coverage"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/matrix-org/matrix-js-sdk"
-    },
-    "keywords": [
-        "matrix-org"
-    ],
-    "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": [
-        "dist",
-        "lib",
-        "src",
-        "git-revision.txt",
-        "CHANGELOG.md",
-        "CONTRIBUTING.rst",
-        "LICENSE",
-        "README.md",
-        "package.json",
-        "release.sh"
-    ],
-    "dependencies": {
-        "@babel/runtime": "^7.12.5",
-        "@matrix-org/matrix-sdk-crypto-wasm": "^1.2.3-alpha.0",
-        "another-json": "^0.2.0",
-        "bs58": "^5.0.0",
-        "content-type": "^1.0.4",
-        "jwt-decode": "^3.1.2",
-        "loglevel": "^1.7.1",
-        "matrix-events-sdk": "0.0.1",
-        "matrix-widget-api": "^1.6.0",
-        "oidc-client-ts": "^2.2.4",
-        "p-retry": "4",
-        "sdp-transform": "^2.14.1",
-        "unhomoglyph": "^1.0.6",
-        "uuid": "9"
-    },
-    "devDependencies": {
-        "@babel/cli": "^7.12.10",
-        "@babel/core": "^7.12.10",
-        "@babel/eslint-parser": "^7.12.10",
-        "@babel/eslint-plugin": "^7.12.10",
-        "@babel/plugin-proposal-class-properties": "^7.12.1",
-        "@babel/plugin-proposal-numeric-separator": "^7.12.7",
-        "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
-        "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-        "@babel/plugin-transform-runtime": "^7.12.10",
-        "@babel/preset-env": "^7.12.11",
-        "@babel/preset-typescript": "^7.12.7",
-        "@babel/register": "^7.12.10",
-        "@casualbot/jest-sonar-reporter": "^2.2.5",
-        "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz",
-        "@types/bs58": "^4.0.1",
-        "@types/content-type": "^1.1.5",
-        "@types/debug": "^4.1.7",
-        "@types/domexception": "^4.0.0",
-        "@types/jest": "^29.0.0",
-        "@types/node": "18",
-        "@types/sdp-transform": "^2.4.5",
-        "@types/uuid": "9",
-        "@typescript-eslint/eslint-plugin": "^5.45.0",
-        "@typescript-eslint/parser": "^5.45.0",
-        "allchange": "^1.0.6",
-        "babel-jest": "^29.0.0",
-        "babelify": "^10.0.0",
-        "browserify": "^17.0.0",
-        "browserify-swap": "^0.2.2",
-        "debug": "^4.3.4",
-        "domexception": "^4.0.0",
-        "eslint": "8.48.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": "^27.1.6",
-        "eslint-plugin-jsdoc": "^46.0.0",
-        "eslint-plugin-matrix-org": "^1.0.0",
-        "eslint-plugin-tsdoc": "^0.2.17",
-        "eslint-plugin-unicorn": "^48.0.0",
-        "exorcist": "^2.0.0",
-        "fake-indexeddb": "^4.0.0",
-        "fetch-mock-jest": "^1.5.1",
-        "jest": "^29.0.0",
-        "jest-environment-jsdom": "^29.0.0",
-        "jest-localstorage-mock": "^2.4.6",
-        "jest-mock": "^29.0.0",
-        "matrix-mock-request": "^2.5.0",
-        "prettier": "2.8.8",
-        "rimraf": "^5.0.0",
-        "terser": "^5.5.1",
-        "ts-node": "^10.9.1",
-        "tsify": "^5.0.2",
-        "typedoc": "^0.24.0",
-        "typedoc-plugin-coverage": "^2.1.0",
-        "typedoc-plugin-mdn-links": "^3.0.3",
-        "typedoc-plugin-missing-exports": "^2.0.0",
-        "typedoc-plugin-versions": "^0.2.3",
-        "typedoc-plugin-versions-cli": "^0.1.12",
-        "typescript": "^5.0.0"
-    },
-    "@casualbot/jest-sonar-reporter": {
-        "outputDirectory": "coverage",
-        "outputName": "jest-sonar-report.xml",
-        "relativePaths": true
-    },
-    "browserify": {
-        "transform": [
-            "browserify-swap",
-            [
-                "babelify",
-                {
-                    "sourceMaps": "inline",
-                    "presets": [
-                        "@babel/preset-env",
-                        "@babel/preset-typescript"
-                    ]
-                }
-            ]
-        ]
-    },
-    "browserify-swap": {
-        "no-rust-crypto": {
-            "src/rust-crypto/index.ts$": "./src/rust-crypto/browserify-index.ts"
-        }
-    },
-    "typings": "./lib/index.d.ts"
+  "name": "matrix-js-sdk",
+  "version": "0.9.2-cryptowraning.1",
+  "description": "Matrix Client-Server SDK for Javascript",
+  "main": "index.js",
+  "scripts": {
+    "test:build": "babel -s -d specbuild spec",
+    "test:run": "istanbul cover --report text --report cobertura --config .istanbul.yml -i \"lib/**/*.js\" node_modules/mocha/bin/_mocha -- --recursive specbuild --colors --reporter mocha-jenkins-reporter --reporter-options junit_report_path=reports/test-results.xml",
+    "test:watch": "mocha --watch --compilers js:babel-core/register --recursive spec --colors",
+    "test": "npm run test:build && npm run test:run",
+    "check": "npm run test:build && _mocha --recursive specbuild --colors",
+    "gendoc": "babel --no-babelrc -d .jsdocbuild src && jsdoc -r .jsdocbuild -P package.json -R README.md -d .jsdoc",
+    "start": "babel -s -w -d lib src",
+    "clean": "rimraf lib dist",
+    "build": "babel -s -d lib src && rimraf dist && mkdir dist && browserify -d browser-index.js | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js && uglifyjs -c -m -o dist/browser-matrix.min.js --source-map dist/browser-matrix.min.js.map --in-source-map dist/browser-matrix.js.map dist/browser-matrix.js",
+    "dist": "npm run build",
+    "watch": "watchify -d browser-index.js -o 'exorcist dist/browser-matrix.js.map > dist/browser-matrix.js' -v",
+    "lint": "eslint --max-warnings 109 src spec",
+    "prepublish": "npm run clean && npm run build && git rev-parse HEAD > git-revision.txt"
+  },
+  "repository": {
+    "url": "https://github.com/matrix-org/matrix-js-sdk"
+  },
+  "keywords": [
+    "matrix-org"
+  ],
+  "browser": "browser-index.js",
+  "author": "matrix.org",
+  "license": "Apache-2.0",
+  "files": [
+    ".babelrc",
+    ".eslintrc.js",
+    "spec/.eslintrc.js",
+    "CHANGELOG.md",
+    "CONTRIBUTING.rst",
+    "LICENSE",
+    "README.md",
+    "RELEASING.md",
+    "examples",
+    "git-hooks",
+    "git-revision.txt",
+    "index.js",
+    "browser-index.js",
+    "jenkins.sh",
+    "lib",
+    "package.json",
+    "release.sh",
+    "spec",
+    "src"
+  ],
+  "dependencies": {
+    "another-json": "^0.2.0",
+    "babel-runtime": "^6.26.0",
+    "bluebird": "^3.5.0",
+    "browser-request": "^0.3.3",
+    "content-type": "^1.0.2",
+    "request": "^2.53.0"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.18.0",
+    "babel-eslint": "^7.1.1",
+    "babel-plugin-transform-async-to-bluebird": "^1.1.1",
+    "babel-plugin-transform-runtime": "^6.23.0",
+    "babel-preset-es2015": "^6.18.0",
+    "browserify": "^14.0.0",
+    "browserify-shim": "^3.8.13",
+    "eslint": "^3.13.1",
+    "eslint-config-google": "^0.7.1",
+    "exorcist": "^0.4.0",
+    "expect": "^1.20.2",
+    "istanbul": "^0.4.5",
+    "jsdoc": "^3.5.5",
+    "lolex": "^1.5.2",
+    "matrix-mock-request": "^1.2.0",
+    "mocha": "^3.2.0",
+    "mocha-jenkins-reporter": "^0.3.6",
+    "rimraf": "^2.5.4",
+    "source-map-support": "^0.4.11",
+    "sourceify": "^0.1.0",
+    "uglify-js": "^2.8.26",
+    "watchify": "^3.2.1"
+  },
+  "browserify": {
+    "transform": [
+      "sourceify"
+    ]
+  }
 }
@@ -1,37 +0,0 @@
-#!/bin/bash
-#
-# Script to perform a post-release steps of matrix-js-sdk.
-#
-# Requires:
-#   jq; install from your distribution's package manager (https://stedolan.github.io/jq/)
-
-set -e
-
-jq --version > /dev/null || (echo "jq is required: please install it"; kill $$)
-
-if [ "$(git branch -lr | grep origin/develop -c)" -ge 1 ]; then
-    # When merging to develop, we need revert the `main` and `typings` fields if we adjusted them previously.
-    for i in main typings 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
-
-    git push origin develop
-fi
@@ -1,31 +1,19 @@
 #!/bin/bash
 #
-# Script to perform a release of matrix-js-sdk and downstream projects.
+# Script to perform a release of matrix-js-sdk.
 #
 # 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
-#   yarn; install via brew (macOS) or similar (https://yarnpkg.com/docs/install/)
-#
-# Note: this script is also used to release matrix-react-sdk, element-web, and element-desktop.
+#   hub; install via brew (OSX) or source/pre-compiled binaries (debian) (https://github.com/github/hub) - Tested on v2.2.9

 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
-yarn --version > /dev/null || (echo "yarn is required: please install it"; kill $$)
+hub --version > /dev/null || (echo "hub is required: please install it"; kill $$)

-USAGE="$0 [-x] [-c changelog_file] vX.Y.Z"
+USAGE="$0 [-xz] [-c changelog_file] vX.Y.Z"

 help() {
    cat <<EOF
@@ -33,9 +21,17 @@ $USAGE

    -c changelog_file:  specify name of file containing changelog
    -x:                 skip updating the changelog
+    -z:                 skip generating the jsdoc
 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
@@ -47,8 +43,9 @@ if ! git diff-files --quiet; then
 fi

 skip_changelog=
+skip_jsdoc=
 changelog_file="CHANGELOG.md"
-while getopts hc:x f; do
+while getopts hc:xz f; do
    case $f in
        h)
            help
@@ -60,81 +57,27 @@ while getopts hc:x f; do
        x)
            skip_changelog=1
            ;;
+        z)
+            skip_jsdoc=1
+            ;;
    esac
 done
-shift $(expr $OPTIND - 1)
+shift `expr $OPTIND - 1`

 if [ $# -ne 1 ]; then
    echo "Usage: $USAGE" >&2
    exit 1
 fi

-function check_dependency {
-    local depver=$(cat package.json | jq -r .dependencies[\"$1\"])
-    if [ "$depver" == "null" ]; then return 0; fi
-
-    echo "Checking version of $1..."
-    local latestver=$(yarn info -s "$1" dist-tags.next)
-    if [ "$depver" != "$latestver" ]
-    then
-        echo "The latest version of $1 is $latestver but package.json depends on $depver."
-        echo -n "Type 'u' to auto-upgrade, 'c' to continue anyway, or 'a' to abort:"
-        read resp
-        if [ "$resp" != "u" ] && [ "$resp" != "c" ]
-        then
-            echo "Aborting."
-            exit 1
-        fi
-        if [ "$resp" == "u" ]
-        then
-            echo "Upgrading $1 to $latestver..."
-            yarn add -E "$1@$latestver"
-            git add -u
-            git commit -m "Upgrade $1 to $latestver"
-        fi
-    fi
-}
-
-function reset_dependency {
-    local depver=$(cat package.json | jq -r .dependencies[\"$1\"])
-    if [ "$depver" == "null" ]; then return 0; fi
-
-    echo "Resetting $1 to develop branch..."
-    yarn add "github:matrix-org/$1#develop"
-    git add -u
-    git commit -m "Reset $1 back to develop branch"
-}
-
-has_subprojects=0
-if [ -f release_config.yaml ]; then
-    subprojects=$(cat release_config.yaml | python -c "import yaml; import sys; print(' '.join(list(yaml.load(sys.stdin)['subprojects'].keys())))" 2> /dev/null)
-    if [ "$?" -eq 0 ]; then
-        has_subprojects=1
-        echo "Checking subprojects for upgrades"
-        for proj in $subprojects; do
-            check_dependency "$proj"
-        done
-    fi
+if [ -z "$skip_changelog" ]; then
+    # update_changelog doesn't have a --version flag
+    update_changelog -h > /dev/null || (echo "github-changelog-generator is required: please install it"; exit)
 fi

-ret=0
-cat package.json | jq '.dependencies[]' | grep -q '#develop' || ret=$?
-if [ "$ret" -eq 0 ]; then
-    echo "package.json contains develop dependencies. Refusing to release."
-    exit
-fi
-
-# We use Git branch / commit dependencies for some packages, and Yarn seems
-# to have a hard time getting that right. See also
-# https://github.com/yarnpkg/yarn/issues/4734. As a workaround, we clean the
-# global cache here to ensure we get the right thing.
-yarn cache clean
-# Ensure all dependencies are updated
-yarn install --ignore-scripts --frozen-lockfile
-
 # 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
@@ -145,15 +88,32 @@ echo $release | grep -q '-' && prerelease=1

 if [ $prerelease -eq 1 ]; then
    echo Making a PRE-RELEASE
-else
-    read -p "Making a FINAL RELEASE, press enter to continue " REPLY
 fi

-rel_branch=$(git symbolic-ref --short HEAD)
+if [ -z "$skip_changelog" ]; then
+    if ! command -v update_changelog >/dev/null 2>&1; then
+        echo "release.sh requires github-changelog-generator. Try:" >&2
+        echo "    pip install git+https://github.com/matrix-org/github-changelog-generator.git" >&2
+        exit 1
+    fi
+fi
+
+# we might already be on the release branch, in which case, yay
+# If we're on any branch starting with 'release', we don't create
+# a separate release branch (this allows us to use the same
+# 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"
+    update_changelog -f "$changelog_file" "$release"
    read -p "Edit $changelog_file manually, or press enter to continue " REPLY

    if [ -n "$(git ls-files --modified $changelog_file)" ]; then
@@ -161,50 +121,26 @@ if [ -z "$skip_changelog" ]; then
        git commit "$changelog_file" -m "Prepare changelog for $tag"
    fi
 fi
-latest_changes=$(mktemp)
-cat "${changelog_file}" | "$(dirname "$0")/scripts/changelog_head.py" > "${latest_changes}"
+latest_changes=`mktemp`
+cat "${changelog_file}" | `dirname $0`/scripts/changelog_head.py > "${latest_changes}"

 set -x

 # Bump package.json and build the dist
-echo "yarn version"
-# yarn version will automatically commit its modification
+echo "npm version"
+# npm 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 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
-
-# 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"
+npm version --no-git-tag-version "$release"
+git commit package.json -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
+    signing_id=`cat release_config.yaml | python -c "import yaml; import sys; print yaml.load(sys.stdin)['signing_id']"`
 fi


@@ -214,21 +150,21 @@ fi
 # 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)
+# (rather than whatever we're pulling in from npm 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')
+    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 --frozen-lockfile
+    npm install
    # We haven't tagged yet, so tell the dist script what version
    # it's building
-    DIST_VERSION="$tag" yarn dist
+    DIST_VERSION="$tag" npm run dist

    popd

@@ -245,7 +181,7 @@ fi
 if [ -n "$signing_id" ]; then
    # make a signed tag
    # gnupg seems to fail to get the right tty device unless we set it here
-    GIT_COMMITTER_EMAIL="$signing_id" GPG_TTY=$(tty) git tag -u "$signing_id" -F "${latest_changes}" "$tag"
+    GIT_COMMITTER_EMAIL="$signing_id" GPG_TTY=`tty` git tag -u "$signing_id" -F "${latest_changes}" "$tag"
 else
    git tag -a -F "${latest_changes}" "$tag"
 fi
@@ -265,12 +201,6 @@ if [ -n "$signing_id" ]; then
    # 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.

-    # This uses git archive which seems to be what github uses. Specifically,
-    # the header fields are set in the same way: same file mode, uid & gid
-    # both zero and mtime set to the timestamp of the commit that the tag
-    # references. Also note that this puts the commit into the tar headers
-    # and can be extracted with gunzip -c foo.tar.gz | git get-tar-commit-id
-
    # the name of the sig file we want to create
    source_sigfile="${tag}-src.tar.gz.asc"

@@ -311,11 +241,11 @@ if [ $prerelease -eq 1 ]; then
    hubflags='-p'
 fi

-release_text=$(mktemp)
+release_text=`mktemp`
 echo "$tag" > "${release_text}"
 echo >> "${release_text}"
 cat "${latest_changes}" >> "${release_text}"
-hub release create $hubflags $assets -F "${release_text}" "$tag"
+hub release create $hubflags $assets -f "${release_text}" "$tag"

 if [ $dodist -eq 0 ]; then
    rm -rf "$builddir"
@@ -323,6 +253,24 @@ fi
 rm "${release_text}"
 rm "${latest_changes}"

+# publish to npmjs
+npm publish
+
+if [ -z "$skip_jsdoc" ]; then
+    echo "generating jsdocs"
+    npm run 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"
+fi
+
 # if it is a pre-release, leave it on the release branch for now.
 if [ $prerelease -eq 1 ]; then
    git checkout "$rel_branch"
@@ -333,25 +281,16 @@ fi
 echo "updating master branch"
 git checkout master
 git pull
-git merge "$rel_branch" --no-edit
+git merge --ff-only "$rel_branch"

-# push master to github
+# push master  and docs (if generated) 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
-    git push origin develop
+if [ -z "$skip_jsdoc" ]; then
+    git push origin gh-pages
 fi

-[ -x ./post-release.sh ] && ./post-release.sh
-
-if [ $has_subprojects -eq 1 ] && [ $prerelease -eq 0 ]; then
-    echo "Resetting subprojects to develop"
-    for proj in $subprojects; do
-        reset_dependency "$proj"
-    done
-    git push origin develop
-fi
+# finally, merge master back onto develop
+git checkout develop
+git pull
+git merge master
+git push origin develop
@@ -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
@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-
-const fsProm = require("fs/promises");
-
-const PKGJSON = "package.json";
-
-async function main() {
-    const pkgJson = JSON.parse(await fsProm.readFile(PKGJSON, "utf8"));
-    for (const field of ["main", "typings"]) {
-        if (pkgJson["matrix_lib_" + field] !== undefined) {
-            pkgJson[field] = pkgJson["matrix_lib_" + field];
-        }
-    }
-    await fsProm.writeFile(PKGJSON, JSON.stringify(pkgJson, null, 2));
-}
-
-main();
@@ -1,16 +0,0 @@
-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
@@ -0,0 +1,5 @@
+module.exports = {
+    env: {
+        mocha: true,
+    },
+}
@@ -1,6 +1,5 @@
 /*
 Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2019, 2022 The Matrix.org Foundation C.I.C.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,32 +16,31 @@ limitations under the License.

 /**
 * A mock implementation of the webstorage api
+ * @constructor
 */
-export class MockStorageApi {
-    public data: Record<string, string> = {};
-    public keys: string[] = [];
-    public length = 0;
+function MockStorageApi() {
+    this.data = {};
+    this.keys = [];
+    this.length = 0;
+}

-    public setItem(k: string, v: string): void {
+MockStorageApi.prototype = {
+    setItem: function(k, v) {
        this.data[k] = v;
-        this.recalc();
-    }
-
-    public getItem(k: string): string | null {
+        this._recalc();
+    },
+    getItem: function(k) {
        return this.data[k] || null;
-    }
-
-    public removeItem(k: string): void {
+    },
+    removeItem: function(k) {
        delete this.data[k];
-        this.recalc();
-    }
-
-    public key(index: number): string {
+        this._recalc();
+    },
+    key: function(index) {
        return this.keys[index];
-    }
-
-    private recalc(): void {
-        const keys: string[] = [];
+    },
+    _recalc: function() {
+        const keys = [];
        for (const k in this.data) {
            if (!this.data.hasOwnProperty(k)) {
                continue;
@@ -51,5 +49,8 @@ export class MockStorageApi {
        }
        this.keys = keys;
        this.length = keys.length;
-    }
-}
+    },
+};
+
+/** */
+module.exports = MockStorageApi;
@@ -0,0 +1,216 @@
+/*
+Copyright 2016 OpenMarket Ltd
+Copyright 2017 Vector Creations 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.
+*/
+
+"use strict";
+
+// load olm before the sdk if possible
+import './olm-loader';
+
+import sdk from '..';
+import testUtils from './test-utils';
+import MockHttpBackend from 'matrix-mock-request';
+import expect from 'expect';
+import Promise from 'bluebird';
+
+/**
+ * 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.
+ */
+export default function TestClient(
+    userId, deviceId, accessToken, sessionStoreBackend,
+) {
+    this.userId = userId;
+    this.deviceId = deviceId;
+
+    if (sessionStoreBackend === undefined) {
+        sessionStoreBackend = new testUtils.MockStorageApi();
+    }
+    this.storage = new sdk.WebStorageSessionStore(sessionStoreBackend);
+    this.httpBackend = new MockHttpBackend();
+    this.client = sdk.createClient({
+        baseUrl: "http://" + userId + ".test.server",
+        userId: userId,
+        accessToken: accessToken,
+        deviceId: deviceId,
+        sessionStore: this.storage,
+        request: this.httpBackend.requestFn,
+    });
+
+    this.deviceKeys = null;
+    this.oneTimeKeys = {};
+}
+
+TestClient.prototype.toString = function() {
+    return 'TestClient[' + this.userId + ']';
+};
+
+/**
+ * start the client, and wait for it to initialise.
+ *
+ * @return {Promise}
+ */
+TestClient.prototype.start = function() {
+    console.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(),
+        testUtils.syncPromise(this.client),
+    ]).then(() => {
+        console.log(this + ': started');
+    });
+};
+
+/**
+ * stop the client
+ */
+TestClient.prototype.stop = function() {
+    this.client.stopClient();
+};
+
+/**
+ * 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();
+
+        console.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).toNotEqual({});
+              console.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({});
+            });
+            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() {
+    console.log(`${this}: flushSync`);
+    return Promise.all([
+        this.httpBackend.flush('/sync', 1),
+        testUtils.syncPromise(this.client),
+    ]).then(() => {
+        console.log(`${this}: flushSync completed`);
+    });
+};
@@ -1,266 +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.
-*/
-
-// `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!;
-    }
-}
@@ -1,34 +0,0 @@
-/*
-Copyright 2020 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import "../../dist/browser-matrix"; // uses browser-matrix instead of the src
-import type { default as BrowserMatrix } from "../../src/browser-index";
-
-// stub for browser-matrix browserify tests
-// @ts-ignore
-global.XMLHttpRequest = jest.fn();
-
-afterAll(() => {
-    // clean up XMLHttpRequest mock
-    // @ts-ignore
-    global.XMLHttpRequest = undefined;
-});
-
-// Akin to spec/setupTests.ts - but that won't affect the browser-matrix bundle
-global.matrixcs = {
-    ...global.matrixcs,
-    timeoutSignal: () => new AbortController().signal,
-} as typeof BrowserMatrix;
@@ -1,92 +0,0 @@
-/*
-Copyright 2020 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import HttpBackend from "matrix-mock-request";
-
-import "./setupTests"; // uses browser-matrix instead of the src
-import type { MatrixClient } from "../../src";
-
-const USER_ID = "@user:test.server";
-const DEVICE_ID = "device_id";
-const ACCESS_TOKEN = "access_token";
-const ROOM_ID = "!room_id:server.test";
-
-describe("Browserify Test", function () {
-    let client: MatrixClient;
-    let httpBackend: HttpBackend;
-
-    beforeEach(() => {
-        httpBackend = new HttpBackend();
-        client = new global.matrixcs.MatrixClient({
-            baseUrl: "http://test.server",
-            userId: USER_ID,
-            accessToken: ACCESS_TOKEN,
-            deviceId: DEVICE_ID,
-            fetchFn: httpBackend.fetchFn as typeof global.fetch,
-        });
-
-        httpBackend.when("GET", "/versions").respond(200, {});
-        httpBackend.when("GET", "/pushrules").respond(200, {});
-        httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
-    });
-
-    afterEach(async () => {
-        client.stopClient();
-        client.http.abort();
-        httpBackend.verifyNoOutstandingRequests();
-        httpBackend.verifyNoOutstandingExpectation();
-        await httpBackend.stop();
-    });
-
-    it("Sync", async () => {
-        const event = {
-            type: "m.room.member",
-            room_id: ROOM_ID,
-            content: {
-                membership: "join",
-                name: "Displayname",
-            },
-            event_id: "$foobar",
-        };
-
-        const syncData = {
-            next_batch: "batch1",
-            rooms: {
-                join: {
-                    [ROOM_ID]: {
-                        timeline: {
-                            events: [event],
-                            limited: false,
-                        },
-                    },
-                },
-            },
-        };
-
-        httpBackend.when("GET", "/sync").respond(200, syncData);
-        httpBackend.when("GET", "/sync").respond(200, syncData);
-
-        const syncPromise = new Promise((r) => client.once(global.matrixcs.ClientEvent.Sync, r));
-        const unexpectedErrorFn = jest.fn();
-        client.once(global.matrixcs.ClientEvent.SyncUnexpectedError, unexpectedErrorFn);
-
-        client.startClient();
-
-        await httpBackend.flushAllExpected();
-        await syncPromise;
-        expect(unexpectedErrorFn).not.toHaveBeenCalled();
-    }, 20000); // additional timeout as this test can take quite a while
-});
@@ -1,342 +0,0 @@
-/*
-Copyright 2023 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import 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,
-    USER_CROSS_SIGNING_PRIVATE_KEY_BASE64,
-} from "../../test-utils/test-data";
-import { E2EKeyResponder } from "../../test-utils/E2EKeyResponder";
-
-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);
-
-        await initCrypto(aliceClient);
-    });
-
-    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}]`,
-            );
-        });
-    });
-
-    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();
-        });
-    });
-
-    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));
-        });
-    });
-});
@@ -1,799 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import fetchMock from "fetch-mock-jest";
-import "fake-indexeddb/auto";
-import { IDBFactory } from "fake-indexeddb";
-
-import { createClient, CryptoEvent, ICreateClientOpts, MatrixClient, TypedEventEmitter } from "../../../src";
-import { SyncResponder } from "../../test-utils/SyncResponder";
-import { E2EKeyReceiver } from "../../test-utils/E2EKeyReceiver";
-import { E2EKeyResponder } from "../../test-utils/E2EKeyResponder";
-import { mockInitialApiRequests } from "../../test-utils/mockEndpoints";
-import { awaitDecryption, CRYPTO_BACKENDS, InitCrypto, syncPromise } from "../../test-utils/test-utils";
-import * as testData from "../../test-utils/test-data";
-import { KeyBackupInfo } from "../../../src/crypto-api/keybackup";
-import { IKeyBackup } from "../../../src/crypto/backup";
-
-const ROOM_ID = testData.TEST_ROOM_ID;
-
-/** The homeserver url that we give to the test client, and where we intercept /sync, /keys, etc requests. */
-const TEST_HOMESERVER_URL = "https://alice-server.com";
-
-const TEST_USER_ID = "@alice:localhost";
-const TEST_DEVICE_ID = "xzcvb";
-
-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();
-});
-
-enum MockKeyUploadEvent {
-    KeyUploaded = "KeyUploaded",
-}
-
-type MockKeyUploadEventHandlerMap = {
-    [MockKeyUploadEvent.KeyUploaded]: (roomId: string, sessionId: string, backupVersion: string) => void;
-};
-
-/*
- * Test helper. Returns an event emitter that will emit an event every time fetchmock sees a request to backup a key.
- */
-function mockUploadEmitter(
-    expectedVersion: string,
-): TypedEventEmitter<MockKeyUploadEvent, MockKeyUploadEventHandlerMap> {
-    const emitter = new TypedEventEmitter();
-    fetchMock.put(
-        "path:/_matrix/client/v3/room_keys/keys",
-        (url, request) => {
-            const version = new URLSearchParams(new URL(url).search).get("version");
-            if (version != expectedVersion) {
-                return {
-                    status: 403,
-                    body: {
-                        current_version: expectedVersion,
-                        errcode: "M_WRONG_ROOM_KEYS_VERSION",
-                        error: "Wrong backup version.",
-                    },
-                };
-            }
-            const uploadPayload: IKeyBackup = JSON.parse(request.body?.toString() ?? "{}");
-            let count = 0;
-            for (const [roomId, value] of Object.entries(uploadPayload.rooms)) {
-                for (const sessionId of Object.keys(value.sessions)) {
-                    emitter.emit(MockKeyUploadEvent.KeyUploaded, roomId, sessionId, version);
-                    count++;
-                }
-            }
-            return {
-                status: 200,
-                body: {
-                    count: count,
-                    etag: "abcdefg",
-                },
-            };
-        },
-        {
-            overwriteRoutes: true,
-        },
-    );
-    return emitter;
-}
-
-describe.each(Object.entries(CRYPTO_BACKENDS))("megolm-keys backup (%s)", (backend: string, initCrypto: InitCrypto) => {
-    // oldBackendOnly is an alternative to `it` or `test` which will skip the test if we are running against the
-    // Rust backend. Once we have full support in the rust sdk, it will go away.
-    // const oldBackendOnly = backend === "rust-sdk" ? test.skip : test;
-    // const newBackendOnly = backend === "libolm" ? test.skip : test;
-
-    let aliceClient: MatrixClient;
-    /** an object which intercepts `/sync` requests on the test homeserver */
-    let syncResponder: SyncResponder;
-
-    /** an object which intercepts `/keys/upload` requests on the test homeserver */
-    let e2eKeyReceiver: E2EKeyReceiver;
-    /** an object which intercepts `/keys/query` requests on the test homeserver */
-    let e2eKeyResponder: E2EKeyResponder;
-
-    jest.useFakeTimers();
-
-    beforeEach(async () => {
-        // anything that we don't have a specific matcher for silently returns a 404
-        fetchMock.catch(404);
-        fetchMock.config.warnOnFallback = false;
-
-        mockInitialApiRequests(TEST_HOMESERVER_URL);
-        syncResponder = new SyncResponder(TEST_HOMESERVER_URL);
-        e2eKeyReceiver = new E2EKeyReceiver(TEST_HOMESERVER_URL);
-        e2eKeyResponder = new E2EKeyResponder(TEST_HOMESERVER_URL);
-        e2eKeyResponder.addDeviceKeys(testData.SIGNED_TEST_DEVICE_DATA);
-        e2eKeyResponder.addKeyReceiver(TEST_USER_ID, e2eKeyReceiver);
-    });
-
-    afterEach(async () => {
-        if (aliceClient !== undefined) {
-            await aliceClient.stopClient();
-        }
-
-        // Allow in-flight things to complete before we tear down the test
-        await jest.runAllTimersAsync();
-
-        fetchMock.mockReset();
-    });
-
-    async function initTestClient(opts: Partial<ICreateClientOpts> = {}): Promise<MatrixClient> {
-        const client = createClient({
-            baseUrl: TEST_HOMESERVER_URL,
-            userId: TEST_USER_ID,
-            accessToken: "akjgkrgjs",
-            deviceId: TEST_DEVICE_ID,
-            ...opts,
-        });
-        await initCrypto(client);
-
-        return client;
-    }
-
-    it("Alice checks key backups when receiving a message she can't decrypt", async function () {
-        const syncResponse = {
-            next_batch: 1,
-            rooms: {
-                join: {
-                    [ROOM_ID]: {
-                        timeline: {
-                            events: [testData.ENCRYPTED_EVENT],
-                        },
-                    },
-                },
-            },
-        };
-
-        fetchMock.get(
-            "express:/_matrix/client/v3/room_keys/keys/:room_id/:session_id",
-            testData.CURVE25519_KEY_BACKUP_DATA,
-        );
-        fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
-
-        aliceClient = await initTestClient();
-        const aliceCrypto = aliceClient.getCrypto()!;
-        await aliceCrypto.storeSessionBackupPrivateKey(Buffer.from(testData.BACKUP_DECRYPTION_KEY_BASE64, "base64"));
-
-        // start after saving the private key
-        await aliceClient.startClient();
-
-        // tell Alice to trust the dummy device that signed the backup, and re-check the backup.
-        // XXX: should we automatically re-check after a device becomes verified?
-        await waitForDeviceList();
-        await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-        await aliceClient.getCrypto()!.checkKeyBackupAndEnable();
-
-        // Now, send Alice a message that she won't be able to decrypt, and check that she fetches the key from the backup.
-        syncResponder.sendOrQueueSyncResponse(syncResponse);
-        await syncPromise(aliceClient);
-
-        const room = aliceClient.getRoom(ROOM_ID)!;
-        const event = room.getLiveTimeline().getEvents()[0];
-        await awaitDecryption(event, { waitOnDecryptionFailure: true });
-
-        expect(event.getContent()).toEqual(testData.CLEAR_EVENT.content);
-    });
-
-    describe("recover from backup", () => {
-        it("can restore from backup (Curve25519 version)", async function () {
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
-
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-            await aliceClient.startClient();
-
-            // tell Alice to trust the dummy device that signed the backup
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            const fullBackup = {
-                rooms: {
-                    [ROOM_ID]: {
-                        sessions: {
-                            [testData.MEGOLM_SESSION_DATA.session_id]: testData.CURVE25519_KEY_BACKUP_DATA,
-                        },
-                    },
-                },
-            };
-
-            fetchMock.get("express:/_matrix/client/v3/room_keys/keys", fullBackup);
-
-            const check = await aliceCrypto.checkKeyBackupAndEnable();
-
-            let onKeyCached: () => void;
-            const awaitKeyCached = new Promise<void>((resolve) => {
-                onKeyCached = resolve;
-            });
-
-            const result = await aliceClient.restoreKeyBackupWithRecoveryKey(
-                testData.BACKUP_DECRYPTION_KEY_BASE58,
-                undefined,
-                undefined,
-                check!.backupInfo!,
-                {
-                    cacheCompleteCallback: () => onKeyCached(),
-                },
-            );
-
-            expect(result.imported).toStrictEqual(1);
-
-            await awaitKeyCached;
-        });
-
-        it("recover specific session from backup", async function () {
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
-
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-            await aliceClient.startClient();
-
-            // tell Alice to trust the dummy device that signed the backup
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            fetchMock.get(
-                "express:/_matrix/client/v3/room_keys/keys/:room_id/:session_id",
-                testData.CURVE25519_KEY_BACKUP_DATA,
-            );
-
-            const check = await aliceCrypto.checkKeyBackupAndEnable();
-
-            const result = await aliceClient.restoreKeyBackupWithRecoveryKey(
-                testData.BACKUP_DECRYPTION_KEY_BASE58,
-                ROOM_ID,
-                testData.MEGOLM_SESSION_DATA.session_id,
-                check!.backupInfo!,
-            );
-
-            expect(result.imported).toStrictEqual(1);
-        });
-
-        it("Fails on bad recovery key", async function () {
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
-
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-            await aliceClient.startClient();
-
-            // tell Alice to trust the dummy device that signed the backup
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            const fullBackup = {
-                rooms: {
-                    [ROOM_ID]: {
-                        sessions: {
-                            [testData.MEGOLM_SESSION_DATA.session_id]: testData.CURVE25519_KEY_BACKUP_DATA,
-                        },
-                    },
-                },
-            };
-
-            fetchMock.get("express:/_matrix/client/v3/room_keys/keys", fullBackup);
-
-            const check = await aliceCrypto.checkKeyBackupAndEnable();
-
-            await expect(
-                aliceClient.restoreKeyBackupWithRecoveryKey(
-                    "EsTx A7Xn aNFF k3jH zpV3 MQoN LJEg mscC HecF 982L wC77 mYQD",
-                    undefined,
-                    undefined,
-                    check!.backupInfo!,
-                ),
-            ).rejects.toThrow();
-        });
-    });
-
-    describe("backupLoop", () => {
-        it("Alice should upload known keys when backup is enabled", async function () {
-            // 404 means that there is no active backup
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", 404);
-
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-            await aliceClient.startClient();
-
-            // tell Alice to trust the dummy device that signed the backup
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            // check that signalling is working
-            const remainingZeroPromise = new Promise<void>((resolve, reject) => {
-                aliceClient.on(CryptoEvent.KeyBackupSessionsRemaining, (remaining) => {
-                    if (remaining == 0) {
-                        resolve();
-                    }
-                });
-            });
-
-            const someRoomKeys = testData.MEGOLM_SESSION_DATA_ARRAY;
-
-            const uploadMockEmitter = mockUploadEmitter(testData.SIGNED_BACKUP_DATA.version!);
-
-            const uploadPromises = someRoomKeys.map((data) => {
-                new Promise<void>((resolve) => {
-                    uploadMockEmitter.on(MockKeyUploadEvent.KeyUploaded, (roomId, sessionId, version) => {
-                        if (
-                            data.room_id == roomId &&
-                            data.session_id == sessionId &&
-                            version == testData.SIGNED_BACKUP_DATA.version
-                        ) {
-                            resolve();
-                        }
-                    });
-                });
-            });
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA, {
-                overwriteRoutes: true,
-            });
-
-            const result = await aliceCrypto.checkKeyBackupAndEnable();
-            expect(result).toBeTruthy();
-
-            await aliceCrypto.importRoomKeys(someRoomKeys);
-
-            // The backup loop is waiting a random amount of time to avoid different clients firing at the same time.
-            jest.runAllTimers();
-
-            await Promise.all(uploadPromises);
-
-            // Wait until all keys are backed up to ensure that when a new key is received the loop is restarted
-            await remainingZeroPromise;
-
-            // A new key import should trigger a new upload.
-            const newKey = testData.MEGOLM_SESSION_DATA;
-
-            const newKeyUploadPromise = new Promise<void>((resolve) => {
-                uploadMockEmitter.on(MockKeyUploadEvent.KeyUploaded, (roomId, sessionId, version) => {
-                    if (
-                        newKey.room_id == roomId &&
-                        newKey.session_id == sessionId &&
-                        version == testData.SIGNED_BACKUP_DATA.version
-                    ) {
-                        resolve();
-                    }
-                });
-            });
-
-            await aliceCrypto.importRoomKeys([newKey]);
-
-            jest.runAllTimers();
-            await newKeyUploadPromise;
-        });
-
-        it("Alice should re-upload all keys if a new trusted backup is available", async function () {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-            await aliceClient.startClient();
-
-            // tell Alice to trust the dummy device that signed the backup
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            // check that signalling is working
-            const remainingZeroPromise = new Promise<void>((resolve) => {
-                aliceClient.on(CryptoEvent.KeyBackupSessionsRemaining, (remaining) => {
-                    if (remaining == 0) {
-                        resolve();
-                    }
-                });
-            });
-
-            const someRoomKeys = testData.MEGOLM_SESSION_DATA_ARRAY;
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA, {
-                overwriteRoutes: true,
-            });
-
-            const result = await aliceCrypto.checkKeyBackupAndEnable();
-            expect(result).toBeTruthy();
-
-            mockUploadEmitter(testData.SIGNED_BACKUP_DATA.version!);
-            await aliceCrypto.importRoomKeys(someRoomKeys);
-
-            // The backup loop is waiting a random amount of time to avoid different clients firing at the same time.
-            jest.runAllTimers();
-
-            // wait for all keys to be backed up
-            await remainingZeroPromise;
-
-            const newBackupVersion = "2";
-            const uploadMockEmitter = mockUploadEmitter(newBackupVersion);
-            const newBackup = JSON.parse(JSON.stringify(testData.SIGNED_BACKUP_DATA));
-            newBackup.version = newBackupVersion;
-
-            // Let's simulate that a new backup is available by returning error code on key upload
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", newBackup, {
-                overwriteRoutes: true,
-            });
-
-            // If we import a new key the loop will try to upload to old version, it will
-            // fail then check the current version and switch if trusted
-            const uploadPromises = someRoomKeys.map((data) => {
-                new Promise<void>((resolve) => {
-                    uploadMockEmitter.on(MockKeyUploadEvent.KeyUploaded, (roomId, sessionId, version) => {
-                        if (data.room_id == roomId && data.session_id == sessionId && version == newBackupVersion) {
-                            resolve();
-                        }
-                    });
-                });
-            });
-
-            const disableOldBackup = new Promise<void>((resolve) => {
-                aliceClient.on(CryptoEvent.KeyBackupFailed, (errCode) => {
-                    if (errCode == "M_WRONG_ROOM_KEYS_VERSION") {
-                        resolve();
-                    }
-                });
-            });
-
-            const enableNewBackup = new Promise<void>((resolve) => {
-                aliceClient.on(CryptoEvent.KeyBackupStatus, (enabled) => {
-                    if (enabled) {
-                        resolve();
-                    }
-                });
-            });
-
-            // A new key import should trigger a new upload.
-            const newKey = testData.MEGOLM_SESSION_DATA;
-
-            const newKeyUploadPromise = new Promise<void>((resolve) => {
-                uploadMockEmitter.on(MockKeyUploadEvent.KeyUploaded, (roomId, sessionId, version) => {
-                    if (newKey.room_id == roomId && newKey.session_id == sessionId && version == newBackupVersion) {
-                        resolve();
-                    }
-                });
-            });
-
-            await aliceCrypto.importRoomKeys([newKey]);
-
-            jest.runAllTimers();
-
-            await disableOldBackup;
-            await enableNewBackup;
-
-            jest.runAllTimers();
-
-            await Promise.all(uploadPromises);
-            await newKeyUploadPromise;
-        });
-
-        it("Backup loop should be resistant to network failures", async function () {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-            await aliceClient.startClient();
-
-            // tell Alice to trust the dummy device that signed the backup
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA, {
-                overwriteRoutes: true,
-            });
-
-            // on the first key upload attempt, simulate a network failure
-            const failurePromise = new Promise((resolve) => {
-                fetchMock.put(
-                    "path:/_matrix/client/v3/room_keys/keys",
-                    () => {
-                        resolve(undefined);
-                        throw new TypeError(`Failed to fetch`);
-                    },
-                    {
-                        overwriteRoutes: true,
-                    },
-                );
-            });
-
-            // kick the import loop off and wait for the failed request
-            const someRoomKeys = testData.MEGOLM_SESSION_DATA_ARRAY;
-            await aliceCrypto.importRoomKeys(someRoomKeys);
-
-            const result = await aliceCrypto.checkKeyBackupAndEnable();
-            expect(result).toBeTruthy();
-            jest.runAllTimers();
-            await failurePromise;
-
-            // Fix the endpoint to do successful uploads
-            const successPromise = new Promise((resolve) => {
-                fetchMock.put(
-                    "path:/_matrix/client/v3/room_keys/keys",
-                    () => {
-                        resolve(undefined);
-                        return {
-                            status: 200,
-                            body: {
-                                count: 2,
-                                etag: "abcdefg",
-                            },
-                        };
-                    },
-                    {
-                        overwriteRoutes: true,
-                    },
-                );
-            });
-
-            // check that a `KeyBackupSessionsRemaining` event is emitted with `remaining == 0`
-            const allKeysUploadedPromise = new Promise((resolve) => {
-                aliceClient.on(CryptoEvent.KeyBackupSessionsRemaining, (remaining) => {
-                    if (remaining == 0) {
-                        resolve(undefined);
-                    }
-                });
-            });
-
-            // run the timers, which will make the backup loop redo the request
-            await jest.runAllTimersAsync();
-            await successPromise;
-            await allKeysUploadedPromise;
-        });
-    });
-
-    it("getActiveSessionBackupVersion() should give correct result", async function () {
-        // 404 means that there is no active backup
-        fetchMock.get("express:/_matrix/client/v3/room_keys/version", 404);
-
-        aliceClient = await initTestClient();
-        const aliceCrypto = aliceClient.getCrypto()!;
-        await aliceClient.startClient();
-
-        // tell Alice to trust the dummy device that signed the backup
-        await waitForDeviceList();
-        await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-        await aliceCrypto.checkKeyBackupAndEnable();
-
-        // At this point there is no backup
-        let backupStatus: string | null;
-        backupStatus = await aliceCrypto.getActiveSessionBackupVersion();
-        expect(backupStatus).toBeNull();
-
-        // Serve a backup with no trusted signature
-        const unsignedBackup = JSON.parse(JSON.stringify(testData.SIGNED_BACKUP_DATA));
-        delete unsignedBackup.auth_data.signatures;
-        fetchMock.get("express:/_matrix/client/v3/room_keys/version", unsignedBackup, {
-            overwriteRoutes: true,
-        });
-
-        const checked = await aliceCrypto.checkKeyBackupAndEnable();
-        expect(checked?.backupInfo?.version).toStrictEqual(unsignedBackup.version);
-        expect(checked?.trustInfo?.trusted).toBeFalsy();
-
-        backupStatus = await aliceCrypto.getActiveSessionBackupVersion();
-        expect(backupStatus).toBeNull();
-
-        // Add a valid signature to the backup
-        fetchMock.get("express:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA, {
-            overwriteRoutes: true,
-        });
-
-        // check that signalling is working
-        const backupPromise = new Promise<void>((resolve, reject) => {
-            aliceClient.on(CryptoEvent.KeyBackupStatus, (enabled) => {
-                if (enabled) {
-                    resolve();
-                }
-            });
-        });
-
-        const validCheck = await aliceCrypto.checkKeyBackupAndEnable();
-        expect(validCheck?.trustInfo?.trusted).toStrictEqual(true);
-
-        await backupPromise;
-
-        backupStatus = await aliceCrypto.getActiveSessionBackupVersion();
-        expect(backupStatus).toStrictEqual(testData.SIGNED_BACKUP_DATA.version);
-    });
-
-    describe("isKeyBackupTrusted", () => {
-        it("does not trust a backup signed by an untrusted device", async () => {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-
-            // download the device list, to match the trusted case
-            await aliceClient.startClient();
-            await waitForDeviceList();
-
-            const result = await aliceCrypto.isKeyBackupTrusted(testData.SIGNED_BACKUP_DATA);
-            expect(result).toEqual({ trusted: false, matchesDecryptionKey: false });
-        });
-
-        it("trusts a backup signed by a trusted device", async () => {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-
-            // tell Alice to trust the dummy device that signed the backup
-            await aliceClient.startClient();
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            const result = await aliceCrypto.isKeyBackupTrusted(testData.SIGNED_BACKUP_DATA);
-            expect(result).toEqual({ trusted: true, matchesDecryptionKey: false });
-        });
-
-        it("recognises a backup which matches the decryption key", async () => {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-
-            await aliceClient.startClient();
-            await aliceCrypto.storeSessionBackupPrivateKey(
-                Buffer.from(testData.BACKUP_DECRYPTION_KEY_BASE64, "base64"),
-            );
-
-            const result = await aliceCrypto.isKeyBackupTrusted(testData.SIGNED_BACKUP_DATA);
-            expect(result).toEqual({ trusted: false, matchesDecryptionKey: true });
-        });
-
-        it("is not fooled by a backup which matches the decryption key but uses a different algorithm", async () => {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-
-            await aliceClient.startClient();
-            await aliceCrypto.storeSessionBackupPrivateKey(
-                Buffer.from(testData.BACKUP_DECRYPTION_KEY_BASE64, "base64"),
-            );
-
-            const backup: KeyBackupInfo = JSON.parse(JSON.stringify(testData.SIGNED_BACKUP_DATA));
-            backup.algorithm = "m.megolm_backup.v1.aes-hmac-sha2";
-            const result = await aliceCrypto.isKeyBackupTrusted(backup);
-            expect(result).toEqual({ trusted: false, matchesDecryptionKey: false });
-        });
-    });
-
-    describe("checkKeyBackupAndEnable", () => {
-        it("enables a backup signed by a trusted device", async () => {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-
-            // tell Alice to trust the dummy device that signed the backup
-            await aliceClient.startClient();
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
-
-            const result = await aliceCrypto.checkKeyBackupAndEnable();
-            expect(result).toBeTruthy();
-            expect(result!.trustInfo).toEqual({ trusted: true, matchesDecryptionKey: false });
-            expect(await aliceCrypto.getActiveSessionBackupVersion()).toEqual(testData.SIGNED_BACKUP_DATA.version);
-        });
-
-        it("does not enable a backup signed by an untrusted device", async () => {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-
-            // download the device list, to match the trusted case
-            await aliceClient.startClient();
-            await waitForDeviceList();
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
-
-            const result = await aliceCrypto.checkKeyBackupAndEnable();
-            expect(result).toBeTruthy();
-            expect(result!.trustInfo).toEqual({ trusted: false, matchesDecryptionKey: false });
-            expect(await aliceCrypto.getActiveSessionBackupVersion()).toBeNull();
-        });
-
-        it("disables backup when a new untrusted backup is available", async () => {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-
-            // tell Alice to trust the dummy device that signed the backup
-            await aliceClient.startClient();
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
-
-            const result = await aliceCrypto.checkKeyBackupAndEnable();
-            expect(result).toBeTruthy();
-            expect(await aliceCrypto.getActiveSessionBackupVersion()).toEqual(testData.SIGNED_BACKUP_DATA.version);
-
-            const unsignedBackup = JSON.parse(JSON.stringify(testData.SIGNED_BACKUP_DATA));
-            delete unsignedBackup.auth_data.signatures;
-            unsignedBackup.version = "2";
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", unsignedBackup, {
-                overwriteRoutes: true,
-            });
-
-            await aliceCrypto.checkKeyBackupAndEnable();
-            expect(await aliceCrypto.getActiveSessionBackupVersion()).toBeNull();
-        });
-
-        it("switches backup when a new trusted backup is available", async () => {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-
-            // tell Alice to trust the dummy device that signed the backup
-            await aliceClient.startClient();
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
-
-            const result = await aliceCrypto.checkKeyBackupAndEnable();
-            expect(result).toBeTruthy();
-            expect(await aliceCrypto.getActiveSessionBackupVersion()).toEqual(testData.SIGNED_BACKUP_DATA.version);
-
-            const newBackupVersion = "2";
-            const newBackup = JSON.parse(JSON.stringify(testData.SIGNED_BACKUP_DATA));
-            newBackup.version = newBackupVersion;
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", newBackup, {
-                overwriteRoutes: true,
-            });
-
-            await aliceCrypto.checkKeyBackupAndEnable();
-            expect(await aliceCrypto.getActiveSessionBackupVersion()).toEqual(newBackupVersion);
-        });
-
-        it("Disables when backup is deleted", async () => {
-            aliceClient = await initTestClient();
-            const aliceCrypto = aliceClient.getCrypto()!;
-
-            // tell Alice to trust the dummy device that signed the backup
-            await aliceClient.startClient();
-            await waitForDeviceList();
-            await aliceCrypto.setDeviceVerified(testData.TEST_USER_ID, testData.TEST_DEVICE_ID);
-
-            fetchMock.get("path:/_matrix/client/v3/room_keys/version", testData.SIGNED_BACKUP_DATA);
-
-            const result = await aliceCrypto.checkKeyBackupAndEnable();
-            expect(result).toBeTruthy();
-            expect(await aliceCrypto.getActiveSessionBackupVersion()).toEqual(testData.SIGNED_BACKUP_DATA.version);
-
-            fetchMock.get(
-                "path:/_matrix/client/v3/room_keys/version",
-                {
-                    status: 404,
-                    body: {
-                        errcode: "M_NOT_FOUND",
-                        error: "No backup found",
-                    },
-                },
-                {
-                    overwriteRoutes: true,
-                },
-            );
-            const noResult = await aliceCrypto.checkKeyBackupAndEnable();
-            expect(noResult).toBeNull();
-            expect(await aliceCrypto.getActiveSessionBackupVersion()).toBeNull();
-        });
-    });
-
-    /** make sure that the client knows about the dummy device */
-    async function waitForDeviceList(): Promise<void> {
-        // Completing the initial sync will make the device list download outdated device lists (of which our own
-        // user will be one).
-        syncResponder.sendOrQueueSyncResponse({});
-        // DeviceList has a sleep(5) which we need to make happen
-        await jest.advanceTimersByTimeAsync(10);
-
-        // The client should now know about the dummy device
-        const devices = await aliceClient.getCrypto()!.getUserDeviceInfo([TEST_USER_ID]);
-        expect(devices.get(TEST_USER_ID)!.keys()).toContain(TEST_DEVICE_ID);
-    }
-});
@@ -1,692 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-Copyright 2017 Vector Creations Ltd
-Copyright 2018 New Vector Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/* This file consists of a set of integration tests which try to simulate
- * communication via an Olm-encrypted room between two users, Alice and Bob.
- *
- * Note that megolm (group) conversation is not tested here.
- *
- * See also `crypto.spec.js`.
- */
-
-// load olm before the sdk if possible
-import "../../olm-loader";
-
-import type { Session } from "@matrix-org/olm";
-import type { IDeviceKeys, IOneTimeKey } from "../../../src/@types/crypto";
-import { logger } from "../../../src/logger";
-import * as testUtils from "../../test-utils/test-utils";
-import { TestClient } from "../../TestClient";
-import { CRYPTO_ENABLED, IClaimKeysRequest, IQueryKeysRequest, IUploadKeysRequest } from "../../../src/client";
-import { ClientEvent, IContent, ISendEventResponse, MatrixClient, MatrixEvent } from "../../../src/matrix";
-import { DeviceInfo } from "../../../src/crypto/deviceinfo";
-
-let aliTestClient: TestClient;
-const roomId = "!room:localhost";
-const aliUserId = "@ali:localhost";
-const aliDeviceId = "zxcvb";
-const aliAccessToken = "aseukfgwef";
-let bobTestClient: TestClient;
-const bobUserId = "@bob:localhost";
-const bobDeviceId = "bvcxz";
-const bobAccessToken = "fewgfkuesa";
-let aliMessages: IContent[];
-let bobMessages: IContent[];
-
-type OlmPayload = ReturnType<Session["encrypt"]>;
-
-async function bobUploadsDeviceKeys(): Promise<void> {
-    bobTestClient.expectDeviceKeyUpload();
-    await bobTestClient.httpBackend.flushAllExpected();
-    expect(Object.keys(bobTestClient.deviceKeys!).length).not.toEqual(0);
-}
-
-/**
- * Set an expectation that querier will query uploader's keys; then flush the http request.
- *
- * @returns resolves once the http request has completed.
- */
-function expectQueryKeys(querier: TestClient, uploader: TestClient): Promise<number> {
-    // can't query keys before bob has uploaded them
-    expect(uploader.deviceKeys).toBeTruthy();
-
-    const uploaderKeys: Record<string, IDeviceKeys> = {};
-    uploaderKeys[uploader.deviceId!] = uploader.deviceKeys!;
-    querier.httpBackend.when("POST", "/keys/query").respond(200, function (_path, content: IQueryKeysRequest) {
-        expect(content.device_keys![uploader.userId!]).toEqual([]);
-        const result: Record<string, Record<string, IDeviceKeys>> = {};
-        result[uploader.userId!] = uploaderKeys;
-        return { device_keys: result };
-    });
-    return querier.httpBackend.flush("/keys/query", 1);
-}
-const expectAliQueryKeys = () => expectQueryKeys(aliTestClient, bobTestClient);
-const expectBobQueryKeys = () => expectQueryKeys(bobTestClient, aliTestClient);
-
-/**
- * Set an expectation that ali will claim one of bob's keys; then flush the http request.
- *
- * @returns resolves once the http request has completed.
- */
-async function expectAliClaimKeys(): Promise<void> {
-    const keys = await bobTestClient.awaitOneTimeKeyUpload();
-    aliTestClient.httpBackend.when("POST", "/keys/claim").respond(200, function (_path, content: IClaimKeysRequest) {
-        const claimType = content.one_time_keys![bobUserId][bobDeviceId];
-        expect(claimType).toEqual("signed_curve25519");
-        let keyId = "";
-        for (keyId in keys) {
-            if (bobTestClient.oneTimeKeys!.hasOwnProperty(keyId)) {
-                if (keyId.indexOf(claimType + ":") === 0) {
-                    break;
-                }
-            }
-        }
-        const result: Record<string, Record<string, Record<string, IOneTimeKey>>> = {};
-        result[bobUserId] = {};
-        result[bobUserId][bobDeviceId] = {};
-        result[bobUserId][bobDeviceId][keyId] = keys[keyId];
-        return { one_time_keys: result };
-    });
-    // it can take a while to process the key query, so give it some extra
-    // time, and make sure the claim actually happens rather than ploughing on
-    // confusingly.
-    const r = await aliTestClient.httpBackend.flush("/keys/claim", 1, 500);
-    expect(r).toEqual(1);
-}
-
-async function aliDownloadsKeys(): Promise<void> {
-    // can't query keys before bob has uploaded them
-    expect(bobTestClient.getSigningKey()).toBeTruthy();
-
-    const p1 = async () => {
-        await aliTestClient.client.downloadKeys([bobUserId]);
-        const devices = aliTestClient.client.getStoredDevicesForUser(bobUserId);
-        expect(devices.length).toEqual(1);
-        expect(devices[0].deviceId).toEqual("bvcxz");
-    };
-    const p2 = expectAliQueryKeys;
-
-    // check that the localStorage is updated as we expect (not sure this is
-    // an integration test, but meh)
-    await Promise.all([p1(), p2()]);
-    await aliTestClient.client.crypto!.deviceList.saveIfDirty();
-    // @ts-ignore - protected
-    aliTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-        const devices = data!.devices[bobUserId]!;
-        expect(devices[bobDeviceId].keys).toEqual(bobTestClient.deviceKeys!.keys);
-        expect(devices[bobDeviceId].verified).toBe(DeviceInfo.DeviceVerification.UNVERIFIED);
-    });
-}
-
-async function clientEnablesEncryption(client: MatrixClient): Promise<void> {
-    await client.setRoomEncryption(roomId, {
-        algorithm: "m.olm.v1.curve25519-aes-sha2",
-    });
-    expect(client.isRoomEncrypted(roomId)).toBeTruthy();
-}
-const aliEnablesEncryption = () => clientEnablesEncryption(aliTestClient.client);
-const bobEnablesEncryption = () => clientEnablesEncryption(bobTestClient.client);
-
-/**
- * Ali sends a message, first claiming e2e keys. Set the expectations and
- * check the results.
- *
- * @returns which resolves to the ciphertext for Bob's device.
- */
-async function aliSendsFirstMessage(): Promise<OlmPayload> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_, ciphertext] = await Promise.all([
-        sendMessage(aliTestClient.client),
-        expectAliQueryKeys().then(expectAliClaimKeys).then(expectAliSendMessageRequest),
-    ]);
-    return ciphertext;
-}
-
-/**
- * Ali sends a message without first claiming e2e keys. Set the expectations
- * and check the results.
- *
- * @returns which resolves to the ciphertext for Bob's device.
- */
-async function aliSendsMessage(): Promise<OlmPayload> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_, ciphertext] = await Promise.all([sendMessage(aliTestClient.client), expectAliSendMessageRequest()]);
-    return ciphertext;
-}
-
-/**
- * Bob sends a message, first querying (but not claiming) e2e keys. Set the
- * expectations and check the results.
- *
- * @returns which resolves to the ciphertext for Ali's device.
- */
-async function bobSendsReplyMessage(): Promise<OlmPayload> {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_, ciphertext] = await Promise.all([
-        sendMessage(bobTestClient.client),
-        expectBobQueryKeys().then(expectBobSendMessageRequest),
-    ]);
-    return ciphertext;
-}
-
-/**
- * Set an expectation that Ali will send a message, and flush the request
- *
- * @returns which resolves to the ciphertext for Bob's device.
- */
-async function expectAliSendMessageRequest(): Promise<OlmPayload> {
-    const content = await expectSendMessageRequest(aliTestClient.httpBackend);
-    aliMessages.push(content);
-    expect(Object.keys(content.ciphertext)).toEqual([bobTestClient.getDeviceKey()]);
-    const ciphertext = content.ciphertext[bobTestClient.getDeviceKey()];
-    expect(ciphertext).toBeTruthy();
-    return ciphertext;
-}
-
-/**
- * Set an expectation that Bob will send a message, and flush the request
- *
- * @returns which resolves to the ciphertext for Bob's device.
- */
-async function expectBobSendMessageRequest(): Promise<OlmPayload> {
-    const content = await expectSendMessageRequest(bobTestClient.httpBackend);
-    bobMessages.push(content);
-    const aliKeyId = "curve25519:" + aliDeviceId;
-    const aliDeviceCurve25519Key = aliTestClient.deviceKeys!.keys[aliKeyId];
-    expect(Object.keys(content.ciphertext)).toEqual([aliDeviceCurve25519Key]);
-    const ciphertext = content.ciphertext[aliDeviceCurve25519Key];
-    expect(ciphertext).toBeTruthy();
-    return ciphertext;
-}
-
-function sendMessage(client: MatrixClient): Promise<ISendEventResponse> {
-    return client.sendMessage(roomId, { msgtype: "m.text", body: "Hello, World" });
-}
-
-async function expectSendMessageRequest(httpBackend: TestClient["httpBackend"]): Promise<IContent> {
-    const path = "/send/m.room.encrypted/";
-    const prom = new Promise<IContent>((resolve) => {
-        httpBackend.when("PUT", path).respond(200, function (_path, content) {
-            resolve(content);
-            return {
-                event_id: "asdfgh",
-            };
-        });
-    });
-
-    // it can take a while to process the key query
-    await httpBackend.flush(path, 1);
-    return prom;
-}
-
-function aliRecvMessage(): Promise<void> {
-    const message = bobMessages.shift()!;
-    return recvMessage(aliTestClient.httpBackend, aliTestClient.client, bobUserId, message);
-}
-
-function bobRecvMessage(): Promise<void> {
-    const message = aliMessages.shift()!;
-    return recvMessage(bobTestClient.httpBackend, bobTestClient.client, aliUserId, message);
-}
-
-async function recvMessage(
-    httpBackend: TestClient["httpBackend"],
-    client: MatrixClient,
-    sender: string,
-    message: IContent,
-): Promise<void> {
-    const syncData = {
-        next_batch: "x",
-        rooms: {
-            join: {
-                [roomId]: {
-                    timeline: {
-                        events: [
-                            testUtils.mkEvent({
-                                type: "m.room.encrypted",
-                                room: roomId,
-                                content: message,
-                                sender: sender,
-                            }),
-                        ],
-                    },
-                },
-            },
-        },
-    };
-    httpBackend.when("GET", "/sync").respond(200, syncData);
-
-    const eventPromise = new Promise<MatrixEvent>((resolve) => {
-        const onEvent = function (event: MatrixEvent) {
-            // ignore the m.room.member events
-            if (event.getType() == "m.room.member") {
-                return;
-            }
-            logger.log(client.credentials.userId + " received event", event);
-
-            client.removeListener(ClientEvent.Event, onEvent);
-            resolve(event);
-        };
-        client.on(ClientEvent.Event, onEvent);
-    });
-
-    await httpBackend.flushAllExpected();
-
-    const preDecryptionEvent = await eventPromise;
-    expect(preDecryptionEvent.isEncrypted()).toBeTruthy();
-    // it may still be being decrypted
-    const event = await testUtils.awaitDecryption(preDecryptionEvent);
-    expect(event.getType()).toEqual("m.room.message");
-    expect(event.getContent()).toMatchObject({
-        msgtype: "m.text",
-        body: "Hello, World",
-    });
-    expect(event.isEncrypted()).toBeTruthy();
-}
-
-/**
- * Send an initial sync response to the client (which just includes the member
- * list for our test room).
- *
- * @returns which resolves when the sync has been flushed.
- */
-function firstSync(testClient: TestClient): Promise<void> {
-    // send a sync response including our test room.
-    const syncData = {
-        next_batch: "x",
-        rooms: {
-            join: {
-                [roomId]: {
-                    state: {
-                        events: [
-                            testUtils.mkMembership({
-                                mship: "join",
-                                user: aliUserId,
-                            }),
-                            testUtils.mkMembership({
-                                mship: "join",
-                                user: bobUserId,
-                            }),
-                        ],
-                    },
-                    timeline: {
-                        events: [],
-                    },
-                },
-            },
-        },
-    };
-
-    testClient.httpBackend.when("GET", "/sync").respond(200, syncData);
-    return testClient.flushSync();
-}
-
-describe("MatrixClient crypto", () => {
-    if (!CRYPTO_ENABLED) {
-        return;
-    }
-
-    beforeEach(async () => {
-        aliTestClient = new TestClient(aliUserId, aliDeviceId, aliAccessToken);
-        await aliTestClient.client.initCrypto();
-
-        bobTestClient = new TestClient(bobUserId, bobDeviceId, bobAccessToken);
-        await bobTestClient.client.initCrypto();
-
-        aliMessages = [];
-        bobMessages = [];
-    });
-
-    afterEach(() => {
-        aliTestClient.httpBackend.verifyNoOutstandingExpectation();
-        bobTestClient.httpBackend.verifyNoOutstandingExpectation();
-
-        return Promise.all([aliTestClient.stop(), bobTestClient.stop()]);
-    });
-
-    it("Bob uploads device keys", bobUploadsDeviceKeys);
-
-    it("handles failures to upload device keys", async () => {
-        // since device keys are uploaded asynchronously, there's not really much to do here other than fail the
-        // upload.
-        bobTestClient.httpBackend.when("POST", "/keys/upload").fail(0, new Error("bleh"));
-        await bobTestClient.httpBackend.flushAllExpected();
-    });
-
-    it("Ali downloads Bobs device keys", async () => {
-        await bobUploadsDeviceKeys();
-        await aliDownloadsKeys();
-    });
-
-    it("Ali gets keys with an invalid signature", async () => {
-        await bobUploadsDeviceKeys();
-        // tamper bob's keys
-        const bobDeviceKeys = bobTestClient.deviceKeys!;
-        expect(bobDeviceKeys.keys["curve25519:" + bobDeviceId]).toBeTruthy();
-        bobDeviceKeys.keys["curve25519:" + bobDeviceId] += "abc";
-        await Promise.all([aliTestClient.client.downloadKeys([bobUserId]), expectAliQueryKeys()]);
-        const devices = aliTestClient.client.getStoredDevicesForUser(bobUserId);
-        // should get an empty list
-        expect(devices).toEqual([]);
-    });
-
-    it("Ali gets keys with an incorrect userId", async () => {
-        const eveUserId = "@eve:localhost";
-
-        const bobDeviceKeys = {
-            algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
-            device_id: "bvcxz",
-            keys: {
-                "ed25519:bvcxz": "pYuWKMCVuaDLRTM/eWuB8OlXEb61gZhfLVJ+Y54tl0Q",
-                "curve25519:bvcxz": "7Gni0loo/nzF0nFp9847RbhElGewzwUXHPrljjBGPTQ",
-            },
-            user_id: "@eve:localhost",
-            signatures: {
-                "@eve:localhost": {
-                    "ed25519:bvcxz":
-                        "CliUPZ7dyVPBxvhSA1d+X+LYa5b2AYdjcTwG" + "0stXcIxjaJNemQqtdgwKDtBFl3pN2I13SEijRDCf1A8bYiQMDg",
-                },
-            },
-        };
-
-        const bobKeys: Record<string, typeof bobDeviceKeys> = {};
-        bobKeys[bobDeviceId] = bobDeviceKeys;
-        aliTestClient.httpBackend.when("POST", "/keys/query").respond(200, { device_keys: { [bobUserId]: bobKeys } });
-
-        await Promise.all([
-            aliTestClient.client.downloadKeys([bobUserId, eveUserId]),
-            aliTestClient.httpBackend.flush("/keys/query", 1),
-        ]);
-        const [bobDevices, eveDevices] = await Promise.all([
-            aliTestClient.client.getStoredDevicesForUser(bobUserId),
-            aliTestClient.client.getStoredDevicesForUser(eveUserId),
-        ]);
-        // should get an empty list
-        expect(bobDevices).toEqual([]);
-        expect(eveDevices).toEqual([]);
-    });
-
-    it("Ali gets keys with an incorrect deviceId", async () => {
-        const bobDeviceKeys = {
-            algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
-            device_id: "bad_device",
-            keys: {
-                "ed25519:bad_device": "e8XlY5V8x2yJcwa5xpSzeC/QVOrU+D5qBgyTK0ko+f0",
-                "curve25519:bad_device": "YxuuLG/4L5xGeP8XPl5h0d7DzyYVcof7J7do+OXz0xc",
-            },
-            user_id: "@bob:localhost",
-            signatures: {
-                "@bob:localhost": {
-                    "ed25519:bad_device":
-                        "fEFTq67RaSoIEVBJ8DtmRovbwUBKJ0A" + "me9m9PDzM9azPUwZ38Xvf6vv1A7W1PSafH4z3Y2ORIyEnZgHaNby3CQ",
-                },
-            },
-        };
-
-        const bobKeys: Record<string, typeof bobDeviceKeys> = {};
-        bobKeys[bobDeviceId] = bobDeviceKeys;
-        aliTestClient.httpBackend.when("POST", "/keys/query").respond(200, { device_keys: { [bobUserId]: bobKeys } });
-
-        await Promise.all([
-            aliTestClient.client.downloadKeys([bobUserId]),
-            aliTestClient.httpBackend.flush("/keys/query", 1),
-        ]);
-        const devices = aliTestClient.client.getStoredDevicesForUser(bobUserId);
-        // should get an empty list
-        expect(devices).toEqual([]);
-    });
-
-    it("Bob starts his client and uploads device keys and one-time keys", async () => {
-        await bobTestClient.start();
-        const keys = await bobTestClient.awaitOneTimeKeyUpload();
-        expect(Object.keys(keys).length).toEqual(5);
-        expect(Object.keys(bobTestClient.deviceKeys!).length).not.toEqual(0);
-    });
-
-    it("Ali sends a message", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-    });
-
-    it("Bob receives a message", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        bobTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve(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();
-    });
-});
@@ -1,105 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import "fake-indexeddb/auto";
-import { IDBFactory } from "fake-indexeddb";
-
-import { createClient } from "../../../src";
-
-afterEach(() => {
-    // reset fake-indexeddb after each test, to make sure we don't leak connections
-    // cf https://github.com/dumbmatter/fakeIndexedDB#wipingresetting-the-indexeddb-for-a-fresh-state
-    // eslint-disable-next-line no-global-assign
-    indexedDB = new IDBFactory();
-});
-
-describe("MatrixClient.initRustCrypto", () => {
-    it("should raise if userId or deviceId is unknown", async () => {
-        const unknownUserClient = createClient({
-            baseUrl: "http://test.server",
-            deviceId: "aliceDevice",
-        });
-        await expect(() => unknownUserClient.initRustCrypto()).rejects.toThrow("unknown userId");
-
-        const unknownDeviceClient = createClient({
-            baseUrl: "http://test.server",
-            userId: "@alice:test",
-        });
-        await expect(() => unknownDeviceClient.initRustCrypto()).rejects.toThrow("unknown deviceId");
-    });
-
-    it("should create the indexed dbs", async () => {
-        const matrixClient = createClient({
-            baseUrl: "http://test.server",
-            userId: "@alice:localhost",
-            deviceId: "aliceDevice",
-        });
-
-        // No databases.
-        expect(await indexedDB.databases()).toHaveLength(0);
-
-        await matrixClient.initRustCrypto();
-
-        // should have two dbs now
-        const databaseNames = (await indexedDB.databases()).map((db) => db.name);
-        expect(databaseNames).toEqual(
-            expect.arrayContaining(["matrix-js-sdk::matrix-sdk-crypto", "matrix-js-sdk::matrix-sdk-crypto-meta"]),
-        );
-    });
-
-    it("should ignore a second call", async () => {
-        const matrixClient = createClient({
-            baseUrl: "http://test.server",
-            userId: "@alice:localhost",
-            deviceId: "aliceDevice",
-        });
-
-        await matrixClient.initRustCrypto();
-        await matrixClient.initRustCrypto();
-    });
-});
-
-describe("MatrixClient.clearStores", () => {
-    it("should clear the indexeddbs", async () => {
-        const matrixClient = createClient({
-            baseUrl: "http://test.server",
-            userId: "@alice:localhost",
-            deviceId: "aliceDevice",
-        });
-
-        await matrixClient.initRustCrypto();
-        expect(await indexedDB.databases()).toHaveLength(2);
-        await matrixClient.stopClient();
-
-        await matrixClient.clearStores();
-        expect(await indexedDB.databases()).toHaveLength(0);
-    });
-
-    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
-    });
-});
@@ -0,0 +1,369 @@
+import expect from 'expect';
+import Promise from 'bluebird';
+
+import TestClient from '../TestClient';
+import testUtils from '../test-utils';
+
+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) {
+        console.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() {
+        testUtils.beforeEach(this); // eslint-disable-line no-invalid-this
+
+        // we create our own sessionStoreBackend so that we can use it for
+        // another TestClient.
+        sessionStoreBackend = new testUtils.MockStorageApi();
+
+        aliceTestClient = await createTestClient();
+    });
+
+    afterEach(function() {
+        aliceTestClient.stop();
+    });
+
+    it("Alice shouldn't do a second /query for non-e2e-capable devices", function() {
+        return aliceTestClient.start().then(function() {
+            const syncResponse = getSyncResponse(['@bob:xyz']);
+            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            console.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() {
+            console.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/riot-web/issues/3126
+           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),
+                   ),
+               ]);
+           }).then(() => {
+               expect(aliceTestClient.storage.getEndToEndDeviceSyncToken()).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);
+               const bobStat = aliceTestClient.storage
+                     .getEndToEndDeviceTrackingStatus()['@bob:xyz'];
+               if (bobStat != 1 && bobStat != 2) {
+                   throw new Error('Unexpected status for bob: wanted 1 or 2, got ' +
+                                   bobStat);
+               }
+
+               const chrisStat = aliceTestClient.storage
+                     .getEndToEndDeviceTrackingStatus()['@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(() => {
+               const bobStat = aliceTestClient.storage
+                     .getEndToEndDeviceTrackingStatus()['@bob:xyz'];
+               expect(bobStat).toEqual(3);
+               const chrisStat = aliceTestClient.storage
+                     .getEndToEndDeviceTrackingStatus()['@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(() => {
+               const bobStat = aliceTestClient.storage
+                     .getEndToEndDeviceTrackingStatus()['@bob:xyz'];
+               const chrisStat = aliceTestClient.storage
+                     .getEndToEndDeviceTrackingStatus()['@chris:abc'];
+
+               expect(bobStat).toEqual(3);
+               expect(chrisStat).toEqual(3);
+               expect(aliceTestClient.storage.getEndToEndDeviceSyncToken()).toEqual(3);
+           });
+       });
+
+    // https://github.com/vector-im/riot-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);
+
+            const bobStat = aliceTestClient.storage
+                      .getEndToEndDeviceTrackingStatus()['@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();
+
+            const bobStat = aliceTestClient.storage
+                      .getEndToEndDeviceTrackingStatus()['@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();
+
+            const bobStat = aliceTestClient.storage
+                      .getEndToEndDeviceTrackingStatus()['@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 {
+                anotherTestClient.httpBackend.when('GET', '/keys/changes').respond(
+                    200, {
+                        changed: [],
+                        left: ['@bob:xyz'],
+                    },
+                );
+                await anotherTestClient.start();
+                anotherTestClient.httpBackend.when('GET', '/sync').respond(
+                    200, getSyncResponse([]));
+                await anotherTestClient.flushSync();
+
+                const bobStat = anotherTestClient.storage
+                      .getEndToEndDeviceTrackingStatus()['@bob:xyz'];
+
+                expect(bobStat).toEqual(
+                    0, "Alice should have marked bob's device list as untracked",
+                );
+            } finally {
+                anotherTestClient.stop();
+            }
+        });
+    });
+});
@@ -1,405 +0,0 @@
-/*
-Copyright 2017 Vector Creations Ltd
-Copyright 2018 New Vector Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import { TestClient } from "../TestClient";
-import * as testUtils from "../test-utils/test-utils";
-import { logger } from "../../src/logger";
-
-const ROOM_ID = "!room:id";
-
-/**
- * get a /sync response which contains a single e2e room (ROOM_ID), with the
- * members given
- *
- * @returns sync response
- */
-function getSyncResponse(roomMembers: string[]) {
-    const stateEvents = [
-        testUtils.mkEvent({
-            type: "m.room.encryption",
-            skey: "",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-            },
-        }),
-    ];
-
-    Array.prototype.push.apply(
-        stateEvents,
-        roomMembers.map((m) =>
-            testUtils.mkMembership({
-                mship: "join",
-                sender: m,
-            }),
-        ),
-    );
-
-    const syncResponse = {
-        next_batch: 1,
-        rooms: {
-            join: {
-                [ROOM_ID]: {
-                    state: {
-                        events: stateEvents,
-                    },
-                },
-            },
-        },
-    };
-
-    return syncResponse;
-}
-
-describe("DeviceList management:", function () {
-    if (!global.Olm) {
-        logger.warn("not running deviceList tests: Olm not present");
-        return;
-    }
-
-    let aliceTestClient: TestClient;
-    let sessionStoreBackend: Storage;
-
-    async function createTestClient() {
-        const testClient = new TestClient("@alice:localhost", "xzcvb", "akjgkrgjs", sessionStoreBackend);
-        await testClient.client.initCrypto();
-        return testClient;
-    }
-
-    beforeEach(async function () {
-        // we create our own sessionStoreBackend so that we can use it for
-        // another TestClient.
-        sessionStoreBackend = new testUtils.MockStorageApi();
-
-        aliceTestClient = await createTestClient();
-    });
-
-    afterEach(function () {
-        return aliceTestClient.stop();
-    });
-
-    it("Alice shouldn't do a second /query for non-e2e-capable devices", function () {
-        aliceTestClient.expectKeyQuery({
-            device_keys: { "@alice:localhost": {} },
-            failures: {},
-        });
-        return aliceTestClient
-            .start()
-            .then(function () {
-                const syncResponse = getSyncResponse(["@bob:xyz"]);
-                aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
-
-                return aliceTestClient.flushSync();
-            })
-            .then(function () {
-                logger.log("Forcing alice to download our device keys");
-
-                aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, {
-                    device_keys: {
-                        "@bob:xyz": {},
-                    },
-                });
-
-                return Promise.all([
-                    aliceTestClient.client.downloadKeys(["@bob:xyz"]),
-                    aliceTestClient.httpBackend.flush("/keys/query", 1),
-                ]);
-            })
-            .then(function () {
-                logger.log("Telling alice to send a megolm message");
-
-                aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, {
-                    event_id: "$event_id",
-                });
-
-                return Promise.all([
-                    aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
-
-                    // the crypto stuff can take a while, so give the requests a whole second.
-                    aliceTestClient.httpBackend.flushAllExpected({
-                        timeout: 1000,
-                    }),
-                ]);
-            });
-    });
-
-    it.skip("We should not get confused by out-of-order device query responses", () => {
-        // https://github.com/vector-im/element-web/issues/3126
-        aliceTestClient.expectKeyQuery({
-            device_keys: { "@alice:localhost": {} },
-            failures: {},
-        });
-        return aliceTestClient
-            .start()
-            .then(() => {
-                aliceTestClient.httpBackend
-                    .when("GET", "/sync")
-                    .respond(200, getSyncResponse(["@bob:xyz", "@chris:abc"]));
-                return aliceTestClient.flushSync();
-            })
-            .then(() => {
-                // to make sure the initial device queries are flushed out, we
-                // attempt to send a message.
-
-                aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, {
-                    device_keys: {
-                        "@bob:xyz": {},
-                        "@chris:abc": {},
-                    },
-                });
-
-                aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, { event_id: "$event1" });
-
-                return Promise.all([
-                    aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
-                    aliceTestClient.httpBackend
-                        .flush("/keys/query", 1)
-                        .then(() => aliceTestClient.httpBackend.flush("/send/", 1)),
-                    aliceTestClient.client.crypto!.deviceList.saveIfDirty(),
-                ]);
-            })
-            .then(() => {
-                // @ts-ignore accessing a protected field
-                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                    expect(data!.syncToken).toEqual(1);
-                });
-
-                // invalidate bob's and chris's device lists in separate syncs
-                aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-                    next_batch: "2",
-                    device_lists: {
-                        changed: ["@bob:xyz"],
-                    },
-                });
-                aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-                    next_batch: "3",
-                    device_lists: {
-                        changed: ["@chris:abc"],
-                    },
-                });
-                // flush both syncs
-                return aliceTestClient.flushSync().then(() => {
-                    return aliceTestClient.flushSync();
-                });
-            })
-            .then(() => {
-                // check that we don't yet have a request for chris's devices.
-                aliceTestClient.httpBackend
-                    .when("POST", "/keys/query", {
-                        device_keys: {
-                            "@chris:abc": {},
-                        },
-                        token: "3",
-                    })
-                    .respond(200, {
-                        device_keys: { "@chris:abc": {} },
-                    });
-                return aliceTestClient.httpBackend.flush("/keys/query", 1);
-            })
-            .then((flushed) => {
-                expect(flushed).toEqual(0);
-                return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-            })
-            .then(() => {
-                // @ts-ignore accessing a protected field
-                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus["@bob:xyz"];
-                    if (bobStat != 1 && bobStat != 2) {
-                        throw new Error("Unexpected status for bob: wanted 1 or 2, got " + bobStat);
-                    }
-                    const chrisStat = data!.trackingStatus["@chris:abc"];
-                    if (chrisStat != 1 && chrisStat != 2) {
-                        throw new Error("Unexpected status for chris: wanted 1 or 2, got " + chrisStat);
-                    }
-                });
-
-                // now add an expectation for a query for bob's devices, and let
-                // it complete.
-                aliceTestClient.httpBackend
-                    .when("POST", "/keys/query", {
-                        device_keys: {
-                            "@bob:xyz": {},
-                        },
-                        token: "2",
-                    })
-                    .respond(200, {
-                        device_keys: { "@bob:xyz": {} },
-                    });
-                return aliceTestClient.httpBackend.flush("/keys/query", 1);
-            })
-            .then((flushed) => {
-                expect(flushed).toEqual(1);
-
-                // wait for the client to stop processing the response
-                return aliceTestClient.client.downloadKeys(["@bob:xyz"]);
-            })
-            .then(() => {
-                return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-            })
-            .then(() => {
-                // @ts-ignore accessing a protected field
-                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus["@bob:xyz"];
-                    expect(bobStat).toEqual(3);
-                    const chrisStat = data!.trackingStatus["@chris:abc"];
-                    if (chrisStat != 1 && chrisStat != 2) {
-                        throw new Error("Unexpected status for chris: wanted 1 or 2, got " + bobStat);
-                    }
-                });
-
-                // now let the query for chris's devices complete.
-                return aliceTestClient.httpBackend.flush("/keys/query", 1);
-            })
-            .then((flushed) => {
-                expect(flushed).toEqual(1);
-
-                // wait for the client to stop processing the response
-                return aliceTestClient.client.downloadKeys(["@chris:abc"]);
-            })
-            .then(() => {
-                return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-            })
-            .then(() => {
-                // @ts-ignore accessing a protected field
-                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus["@bob:xyz"];
-                    const chrisStat = data!.trackingStatus["@bob:xyz"];
-
-                    expect(bobStat).toEqual(3);
-                    expect(chrisStat).toEqual(3);
-                    expect(data!.syncToken).toEqual(3);
-                });
-            });
-    });
-
-    // https://github.com/vector-im/element-web/issues/4983
-    describe("Alice should know she has stale device lists", () => {
-        beforeEach(async function () {
-            await aliceTestClient.start();
-
-            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse(["@bob:xyz"]));
-            await aliceTestClient.flushSync();
-
-            aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, {
-                device_keys: {
-                    "@bob:xyz": {},
-                },
-            });
-            await aliceTestClient.httpBackend.flush("/keys/query", 1);
-            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus["@bob:xyz"];
-
-                // Alice should be tracking bob's device list
-                expect(bobStat).toBeGreaterThan(0);
-            });
-        });
-
-        it("when Bob leaves", async function () {
-            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: 2,
-                device_lists: {
-                    left: ["@bob:xyz"],
-                },
-                rooms: {
-                    join: {
-                        [ROOM_ID]: {
-                            timeline: {
-                                events: [
-                                    testUtils.mkMembership({
-                                        mship: "leave",
-                                        sender: "@bob:xyz",
-                                    }),
-                                ],
-                            },
-                        },
-                    },
-                },
-            });
-
-            await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus["@bob:xyz"];
-
-                // Alice should have marked bob's device list as untracked
-                expect(bobStat).toEqual(0);
-            });
-        });
-
-        it("when Alice leaves", async function () {
-            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: 2,
-                device_lists: {
-                    left: ["@bob:xyz"],
-                },
-                rooms: {
-                    leave: {
-                        [ROOM_ID]: {
-                            timeline: {
-                                events: [
-                                    testUtils.mkMembership({
-                                        mship: "leave",
-                                        sender: "@bob:xyz",
-                                    }),
-                                ],
-                            },
-                        },
-                    },
-                },
-            });
-
-            await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus["@bob:xyz"];
-
-                // Alice should have marked bob's device list as untracked
-                expect(bobStat).toEqual(0);
-            });
-        });
-
-        it("when Bob leaves whilst Alice is offline", async function () {
-            aliceTestClient.stop();
-
-            const anotherTestClient = await createTestClient();
-
-            try {
-                await anotherTestClient.start();
-                anotherTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse([]));
-                await anotherTestClient.flushSync();
-                await anotherTestClient.client?.crypto?.deviceList?.saveIfDirty();
-
-                // @ts-ignore accessing private property
-                anotherTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus["@bob:xyz"];
-
-                    // Alice should have marked bob's device list as untracked
-                    expect(bobStat).toEqual(0);
-                });
-            } finally {
-                anotherTestClient.stop();
-            }
-        });
-    });
-});
@@ -0,0 +1,750 @@
+/*
+Copyright 2016 OpenMarket Ltd
+Copyright 2017 Vector Creations 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.
+*/
+
+/* 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`.
+ */
+
+"use strict";
+import 'source-map-support/register';
+
+// load olm before the sdk if possible
+import '../olm-loader';
+
+import expect from 'expect';
+const sdk = require("../..");
+import Promise from 'bluebird';
+const utils = require("../../lib/utils");
+const testUtils = require("../test-utils");
+const TestClient = require('../TestClient').default;
+
+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).toNotEqual(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({});
+        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;
+    console.log("query result will be", aliKeys);
+
+    bobTestClient.httpBackend.when(
+        "POST", "/keys/query",
+    ).respond(200, function(path, content) {
+        expect(content.device_keys[aliUserId]).toEqual({});
+        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(function() {
+        const devices = aliTestClient.storage.getEndToEndDevicesForUser(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),
+    ]).spread(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(),
+    ]).spread(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),
+    ]).spread(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(utils.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(utils.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 deferred = Promise.defer();
+    httpBackend.when("PUT", path).respond(200, function(path, content) {
+        deferred.resolve(content);
+        return {
+            event_id: "asdfgh",
+        };
+    });
+
+    // it can take a while to process the key query
+    return httpBackend.flush(path, 1).then(() => deferred.promise);
+}
+
+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;
+            }
+            console.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 (!sdk.CRYPTO_ENABLED) {
+        return;
+    }
+
+    beforeEach(async function() {
+        testUtils.beforeEach(this); // eslint-disable-line no-invalid-this
+
+        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.stop();
+        aliTestClient.httpBackend.verifyNoOutstandingExpectation();
+        bobTestClient.stop();
+        bobTestClient.httpBackend.verifyNoOutstandingExpectation();
+    });
+
+    it("Bob uploads device keys", function() {
+        return Promise.resolve()
+            .then(bobUploadsDeviceKeys);
+    });
+
+    it("Ali downloads Bobs device keys", function(done) {
+        Promise.resolve()
+            .then(bobUploadsDeviceKeys)
+            .then(aliDownloadsKeys)
+            .nodeify(done);
+    });
+
+    it("Ali gets keys with an invalid signature", function(done) {
+        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([]);
+            })
+            .nodeify(done);
+    });
+
+    it("Ali gets keys with an incorrect userId", function(done) {
+        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};
+        });
+
+        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),
+            ]);
+        }).spread((bobDevices, eveDevices) => {
+            // should get an empty list
+            expect(bobDevices).toEqual([]);
+            expect(eveDevices).toEqual([]);
+        }).nodeify(done);
+    });
+
+    it("Ali gets keys with an incorrect deviceId", function(done) {
+        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};
+        });
+
+        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([]);
+        }).nodeify(done);
+    });
+
+
+    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).toNotEqual(0);
+            });
+    });
+
+    it("Ali sends a message", function(done) {
+        Promise.resolve()
+            .then(() => aliTestClient.start())
+            .then(() => bobTestClient.start())
+            .then(() => firstSync(aliTestClient))
+            .then(aliEnablesEncryption)
+            .then(aliSendsFirstMessage)
+            .nodeify(done);
+    });
+
+    it("Bob receives a message", function() {
+        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() {
+        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) {
+                        console.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(done) {
+        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]);
+            }).nodeify(done);
+    });
+
+    it("Bob receives two pre-key messages", function(done) {
+        Promise.resolve()
+            .then(() => aliTestClient.start())
+            .then(() => bobTestClient.start())
+            .then(() => firstSync(aliTestClient))
+            .then(aliEnablesEncryption)
+            .then(aliSendsFirstMessage)
+            .then(bobRecvMessage)
+            .then(aliSendsMessage)
+            .then(bobRecvMessage)
+            .nodeify(done);
+    });
+
+    it("Bob replies to the message", function() {
+        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);
+            }).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.
+        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: {
+                        [aliUserId]: {},
+                        [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(() => {
+                console.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(() => {
+                    console.log(aliTestClient + ': started');
+                });
+            })
+            .then(() => httpBackend.when("POST", "/keys/upload")
+                .respond(200, (path, content) => {
+                    expect(content.one_time_keys).toBeTruthy();
+                    expect(content.one_time_keys).toNotEqual({});
+                    expect(Object.keys(content.one_time_keys).length)
+                        .toBeGreaterThanOrEqualTo(1);
+                    console.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());
+    });
+});
@@ -0,0 +1,320 @@
+"use strict";
+import 'source-map-support/register';
+const sdk = require("../..");
+const HttpBackend = require("matrix-mock-request");
+const utils = require("../test-utils");
+
+import expect from 'expect';
+import Promise from 'bluebird';
+
+describe("MatrixClient events", function() {
+    const baseUrl = "http://localhost.or.something";
+    let client;
+    let httpBackend;
+    const selfUserId = "@alice:localhost";
+    const selfAccessToken = "aseukfgwef";
+
+    beforeEach(function() {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
+        httpBackend = new HttpBackend();
+        sdk.request(httpBackend.requestFn);
+        client = sdk.createClient({
+            baseUrl: baseUrl,
+            userId: selfUserId,
+            accessToken: selfAccessToken,
+        });
+        httpBackend.when("GET", "/pushrules").respond(200, {});
+        httpBackend.when("POST", "/filter").respond(200, { filter_id: "a filter id" });
+    });
+
+    afterEach(function() {
+        httpBackend.verifyNoOutstandingExpectation();
+        client.stopClient();
+    });
+
+    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).toEqual(SYNC_DATA.presence.events[0]);
+                expect(user.presence).toEqual(
+                    SYNC_DATA.presence.events[0].content.presence,
+                );
+            });
+            client.startClient();
+
+            httpBackend.flushAllExpected().done(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).toNotEqual(
+                    -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() {
+            httpBackend.when("GET", "/sync").respond(401, { errcode: 'M_UNKNOWN_TOKEN' });
+
+            let sessionLoggedOutCount = 0;
+            client.on("Session.logged_out", function(event, member) {
+                sessionLoggedOutCount++;
+            });
+
+            client.startClient();
+
+            return httpBackend.flushAllExpected().then(function() {
+                expect(sessionLoggedOutCount).toEqual(
+                    1, "Session.logged_out fired wrong number of times",
+                );
+            });
+        });
+    });
+});
@@ -1,329 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import HttpBackend from "matrix-mock-request";
-
-import {
-    ClientEvent,
-    HttpApiEvent,
-    IEvent,
-    MatrixClient,
-    RoomEvent,
-    RoomMemberEvent,
-    RoomStateEvent,
-    UserEvent,
-} from "../../src";
-import * as utils from "../test-utils/test-utils";
-import { TestClient } from "../TestClient";
-
-describe("MatrixClient events", function () {
-    const selfUserId = "@alice:localhost";
-    const selfAccessToken = "aseukfgwef";
-    let client: MatrixClient | undefined;
-    let httpBackend: HttpBackend | undefined;
-
-    const setupTests = (): [MatrixClient, HttpBackend] => {
-        const testClient = new TestClient(selfUserId, "DEVICE", selfAccessToken);
-        const client = testClient.client;
-        const httpBackend = testClient.httpBackend;
-        httpBackend!.when("GET", "/versions").respond(200, {});
-        httpBackend!.when("GET", "/pushrules").respond(200, {});
-        httpBackend!.when("POST", "/filter").respond(200, { filter_id: "a filter id" });
-
-        return [client!, httpBackend];
-    };
-
-    beforeEach(function () {
-        [client!, httpBackend] = setupTests();
-    });
-
-    afterEach(function () {
-        httpBackend?.verifyNoOutstandingExpectation();
-        client?.stopClient();
-        return httpBackend?.stop();
-    });
-
-    describe("emissions", function () {
-        const SYNC_DATA = {
-            next_batch: "s_5_3",
-            presence: {
-                events: [
-                    utils.mkPresence({
-                        user: "@foo:bar",
-                        name: "Foo Bar",
-                        presence: "online",
-                    }),
-                ],
-            },
-            rooms: {
-                join: {
-                    "!erufh:bar": {
-                        timeline: {
-                            events: [
-                                utils.mkMessage({
-                                    room: "!erufh:bar",
-                                    user: "@foo:bar",
-                                    msg: "hmmm",
-                                }),
-                            ],
-                            prev_batch: "s",
-                        },
-                        state: {
-                            events: [
-                                utils.mkMembership({
-                                    room: "!erufh:bar",
-                                    mship: "join",
-                                    user: "@foo:bar",
-                                }),
-                                utils.mkEvent({
-                                    type: "m.room.create",
-                                    room: "!erufh:bar",
-                                    user: "@foo:bar",
-                                    content: {},
-                                }),
-                            ],
-                        },
-                    },
-                },
-            },
-        };
-        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 Room events", function () {
-            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-            let roomInvokeCount = 0;
-            let roomNameInvokeCount = 0;
-            let timelineFireCount = 0;
-            client!.on(ClientEvent.Room, function (room) {
-                roomInvokeCount++;
-                expect(room.roomId).toEqual("!erufh:bar");
-            });
-            client!.on(RoomEvent.Timeline, function (event, room) {
-                timelineFireCount++;
-                expect(room?.roomId).toEqual("!erufh:bar");
-            });
-            client!.on(RoomEvent.Name, function (room) {
-                roomNameInvokeCount++;
-            });
-
-            client!.startClient();
-
-            return Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 2)]).then(function () {
-                expect(roomInvokeCount).toEqual(1);
-                expect(roomNameInvokeCount).toEqual(1);
-                expect(timelineFireCount).toEqual(3);
-            });
-        });
-
-        it("should emit RoomState events", function () {
-            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-
-            const roomStateEventTypes = ["m.room.member", "m.room.create"];
-            let eventsInvokeCount = 0;
-            let membersInvokeCount = 0;
-            let newMemberInvokeCount = 0;
-            client!.on(RoomStateEvent.Events, function (event, state) {
-                eventsInvokeCount++;
-                const index = roomStateEventTypes.indexOf(event.getType());
-                expect(index).not.toEqual(-1);
-                if (index >= 0) {
-                    roomStateEventTypes.splice(index, 1);
-                }
-            });
-            client!.on(RoomStateEvent.Members, function (event, state, member) {
-                membersInvokeCount++;
-                expect(member.roomId).toEqual("!erufh:bar");
-                expect(member.userId).toEqual("@foo:bar");
-                expect(member.membership).toEqual("join");
-            });
-            client!.on(RoomStateEvent.NewMember, function (event, state, member) {
-                newMemberInvokeCount++;
-                expect(member.roomId).toEqual("!erufh:bar");
-                expect(member.userId).toEqual("@foo:bar");
-                expect(member.membership).toBeFalsy();
-            });
-
-            client!.startClient();
-
-            return Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 2)]).then(function () {
-                expect(membersInvokeCount).toEqual(1);
-                expect(newMemberInvokeCount).toEqual(1);
-                expect(eventsInvokeCount).toEqual(2);
-            });
-        });
-
-        it("should emit RoomMember events", function () {
-            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-
-            let typingInvokeCount = 0;
-            let powerLevelInvokeCount = 0;
-            let nameInvokeCount = 0;
-            let membershipInvokeCount = 0;
-            client!.on(RoomMemberEvent.Name, function (event, member) {
-                nameInvokeCount++;
-            });
-            client!.on(RoomMemberEvent.Typing, function (event, member) {
-                typingInvokeCount++;
-                expect(member.typing).toBe(true);
-            });
-            client!.on(RoomMemberEvent.PowerLevel, function (event, member) {
-                powerLevelInvokeCount++;
-            });
-            client!.on(RoomMemberEvent.Membership, function (event, member) {
-                membershipInvokeCount++;
-                expect(member.membership).toEqual("join");
-            });
-
-            client!.startClient();
-
-            return Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 2)]).then(function () {
-                expect(typingInvokeCount).toEqual(1);
-                expect(powerLevelInvokeCount).toEqual(0);
-                expect(nameInvokeCount).toEqual(0);
-                expect(membershipInvokeCount).toEqual(1);
-            });
-        });
-
-        it("should emit Session.logged_out on M_UNKNOWN_TOKEN", function () {
-            const error = { errcode: "M_UNKNOWN_TOKEN" };
-            httpBackend!.when("GET", "/sync").respond(401, error);
-
-            let sessionLoggedOutCount = 0;
-            client!.on(HttpApiEvent.SessionLoggedOut, function (errObj) {
-                sessionLoggedOutCount++;
-                expect(errObj.data).toEqual(error);
-            });
-
-            client!.startClient();
-
-            return httpBackend!.flushAllExpected().then(function () {
-                expect(sessionLoggedOutCount).toEqual(1);
-            });
-        });
-
-        it("should emit Session.logged_out on M_UNKNOWN_TOKEN (soft logout)", function () {
-            const error = { errcode: "M_UNKNOWN_TOKEN", soft_logout: true };
-            httpBackend!.when("GET", "/sync").respond(401, error);
-
-            let sessionLoggedOutCount = 0;
-            client!.on(HttpApiEvent.SessionLoggedOut, function (errObj) {
-                sessionLoggedOutCount++;
-                expect(errObj.data).toEqual(error);
-            });
-
-            client!.startClient();
-
-            return httpBackend!.flushAllExpected().then(function () {
-                expect(sessionLoggedOutCount).toEqual(1);
-            });
-        });
-    });
-});
@@ -0,0 +1,768 @@
+"use strict";
+import 'source-map-support/register';
+import Promise from 'bluebird';
+const sdk = require("../..");
+const HttpBackend = require("matrix-mock-request");
+const utils = require("../test-utils");
+const EventTimeline = sdk.EventTimeline;
+
+const baseUrl = "http://localhost.or.something";
+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 deferred = Promise.defer();
+    client.on("sync", function(state) {
+        console.log("sync", state);
+        if (state != "SYNCING") {
+            return;
+        }
+        deferred.resolve();
+    });
+
+    return Promise.all([
+        httpBackend.flushAllExpected(),
+        deferred.promise,
+    ]);
+}
+
+describe("getEventTimeline support", function() {
+    let httpBackend;
+    let client;
+
+    beforeEach(function() {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
+        httpBackend = new HttpBackend();
+        sdk.request(httpBackend.requestFn);
+    });
+
+    afterEach(function() {
+        if (client) {
+            client.stopClient();
+        }
+    });
+
+    it("timeline support must be enabled to work", function(done) {
+        client = sdk.createClient({
+            baseUrl: baseUrl,
+            userId: userId,
+            accessToken: accessToken,
+        });
+
+        startClient(httpBackend, client,
+        ).then(function() {
+            const room = client.getRoom(roomId);
+            const timelineSet = room.getTimelineSets()[0];
+            expect(function() {
+                client.getEventTimeline(timelineSet, "event");
+            }).toThrow();
+        }).nodeify(done);
+    });
+
+    it("timeline support works when enabled", function() {
+        client = sdk.createClient({
+            baseUrl: baseUrl,
+            userId: userId,
+            accessToken: accessToken,
+            timelineSupport: true,
+        });
+
+        return startClient(httpBackend, client).then(() => {
+            const room = client.getRoom(roomId);
+            const timelineSet = room.getTimelineSets()[0];
+            expect(function() {
+                client.getEventTimeline(timelineSet, "event");
+            }).toNotThrow();
+        });
+    });
+
+
+    it("scrollback should be able to scroll back to before a gappy /sync",
+      function(done) {
+        // need a client with timelineSupport disabled to make this work
+        client = sdk.createClient({
+            baseUrl: baseUrl,
+            userId: userId,
+            accessToken: accessToken,
+        });
+        let room;
+
+        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");
+        }).nodeify(done);
+    });
+});
+
+import expect from 'expect';
+
+describe("MatrixClient event timelines", function() {
+    let client = null;
+    let httpBackend = null;
+
+    beforeEach(function() {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
+        httpBackend = new HttpBackend();
+        sdk.request(httpBackend.requestFn);
+
+        client = sdk.createClient({
+            baseUrl: baseUrl,
+            userId: userId,
+            accessToken: accessToken,
+            timelineSupport: true,
+        });
+
+        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 deferred = Promise.defer();
+            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");
+                }).done(() => deferred.resolve(),
+                        (e) => deferred.reject(e));
+            });
+
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                deferred.promise,
+            ]);
+        });
+
+        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) {
+                    console.log("sendTextMessage completed");
+                    expect(res.event_id).toEqual(event.event_id);
+                    return client.getEventTimeline(timelineSet, event.event_id);
+                }).then(function(tl) {
+                    console.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) {
+                    console.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(done) {
+        // 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);
+
+        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);
+        }).nodeify(done);
+    });
+});
@@ -0,0 +1,418 @@
+"use strict";
+import 'source-map-support/register';
+const sdk = require("../..");
+const HttpBackend = require("matrix-mock-request");
+const publicGlobals = require("../../lib/matrix");
+const Room = publicGlobals.Room;
+const MatrixInMemoryStore = publicGlobals.MatrixInMemoryStore;
+const Filter = publicGlobals.Filter;
+const utils = require("../test-utils");
+const MockStorageApi = require("../MockStorageApi");
+
+import expect from 'expect';
+
+describe("MatrixClient", function() {
+    const baseUrl = "http://localhost.or.something";
+    let client = null;
+    let httpBackend = null;
+    let store = null;
+    let sessionStore = null;
+    const userId = "@alice:localhost";
+    const accessToken = "aseukfgwef";
+
+    beforeEach(function() {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
+        httpBackend = new HttpBackend();
+        store = new MatrixInMemoryStore();
+
+        const mockStorage = new MockStorageApi();
+        sessionStore = new sdk.WebStorageSessionStore(mockStorage);
+
+        sdk.request(httpBackend.requestFn);
+        client = sdk.createClient({
+            baseUrl: baseUrl,
+            userId: userId,
+            deviceId: "aliceDevice",
+            accessToken: accessToken,
+            store: store,
+            sessionStore: sessionStore,
+        });
+    });
+
+    afterEach(function() {
+        httpBackend.verifyNoOutstandingExpectation();
+    });
+
+    describe("uploadContent", function() {
+        const buf = new Buffer('hello world');
+        it("should upload the file", function(done) {
+            httpBackend.when(
+                "POST", "/_matrix/media/v1/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);
+
+            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);
+            }).nodeify(done);
+
+            httpBackend.flush();
+        });
+
+        it("should parse the response if rawResponse=false", function(done) {
+            httpBackend.when(
+                "POST", "/_matrix/media/v1/upload",
+            ).check(function(req) {
+                expect(req.opts.json).toBeFalsy();
+            }).respond(200, { "content_uri": "uri" });
+
+            client.uploadContent({
+                stream: buf,
+                name: "hi.txt",
+                type: "text/plain",
+            }, {
+                rawResponse: false,
+            }).then(function(response) {
+                expect(response.content_uri).toEqual("uri");
+            }).nodeify(done);
+
+            httpBackend.flush();
+        });
+
+        it("should parse errors into a MatrixError", function(done) {
+            httpBackend.when(
+                "POST", "/_matrix/media/v1/upload",
+            ).check(function(req) {
+                expect(req.rawData).toEqual(buf);
+                expect(req.opts.json).toBeFalsy();
+            }).respond(400, {
+                "errcode": "M_SNAFU",
+                "error": "broken",
+            });
+
+            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");
+            }).nodeify(done);
+
+            httpBackend.flush();
+        });
+
+        it("should return a promise which can be cancelled", function(done) {
+            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);
+
+            prom.then(function(response) {
+                throw Error("request not aborted");
+            }, function(error) {
+                expect(error).toEqual("aborted");
+
+                const uploads = client.getCurrentUploads();
+                expect(uploads.length).toEqual(0);
+            }).nodeify(done);
+
+            const r = client.cancelUpload(prom);
+            expect(r).toBe(true);
+        });
+    });
+
+    describe("joinRoom", function() {
+        it("should no-op if you've already joined a room", function() {
+            const roomId = "!foo:bar";
+            const room = new Room(roomId);
+            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).done(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).done(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).done(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).done(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().done(function() {
+                done();
+            });
+        });
+    });
+
+
+    describe("downloadKeys", function() {
+        if (!sdk.CRYPTO_ENABLED) {
+            return;
+        }
+
+        beforeEach(function() {
+            return client.initCrypto();
+        });
+
+        it("should do an HTTP request and then store the keys", function(done) {
+            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));
+            };
+
+            console.log("Ed25519: " + ed25519key);
+            console.log("boris:", sign(borisKeys.dev1));
+            console.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,
+                },
+            });
+
+            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" },
+                });
+            }).nodeify(done);
+
+            httpBackend.flush();
+        });
+    });
+
+    describe("deleteDevice", function() {
+        const auth = {a: 1};
+        it("should pass through an auth dict", function(done) {
+            httpBackend.when(
+                "DELETE", "/_matrix/client/unstable/devices/my_device",
+            ).check(function(req) {
+                expect(req.data).toEqual({auth: auth});
+            }).respond(200);
+
+            client.deleteDevice(
+                "my_device", auth,
+            ).nodeify(done);
+
+            httpBackend.flush();
+        });
+    });
+});
+
+function assertObjectContains(obj, expected) {
+    for (const k in expected) {
+        if (expected.hasOwnProperty(k)) {
+            expect(obj[k]).toEqual(expected[k]);
+        }
+    }
+}
@@ -0,0 +1,191 @@
+"use strict";
+import 'source-map-support/register';
+const sdk = require("../..");
+const MatrixClient = sdk.MatrixClient;
+const HttpBackend = require("matrix-mock-request");
+const utils = require("../test-utils");
+
+import expect from 'expect';
+import Promise from 'bluebird';
+
+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() {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
+        httpBackend = new HttpBackend();
+    });
+
+    afterEach(function() {
+        httpBackend.verifyNoOutstandingExpectation();
+    });
+
+    describe("without opts.store", function() {
+        beforeEach(function() {
+            client = new MatrixClient({
+                request: httpBackend.requestFn,
+                store: undefined,
+                baseUrl: baseUrl,
+                userId: userId,
+                accessToken: accessToken,
+                scheduler: new sdk.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").done(function(res) {
+                expect(res.event_id).toEqual(eventId);
+                done();
+            });
+            httpBackend.flush("/txn1", 1);
+        });
+
+        it("should be able to sync / get new events", function(done) {
+            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())).toNotEqual(
+                    -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);
+            client.startClient();
+            httpBackend.flush("/pushrules", 1).then(function() {
+                return httpBackend.flush("/filter", 1);
+            }).then(function() {
+                return Promise.all([
+                    httpBackend.flush("/sync", 1),
+                    utils.syncPromise(client),
+                ]);
+            }).done(function() {
+                expect(expectedEventTypes.length).toEqual(
+                    0, "Expected to see event types: " + expectedEventTypes,
+                );
+                done();
+            });
+        });
+    });
+
+    describe("without opts.scheduler", function() {
+        beforeEach(function() {
+            client = new MatrixClient({
+                request: httpBackend.requestFn,
+                store: new sdk.MatrixInMemoryStore(),
+                baseUrl: baseUrl,
+                userId: userId,
+                accessToken: accessToken,
+                scheduler: undefined,
+            });
+        });
+
+        it("shouldn't retry sending events", function(done) {
+            httpBackend.when("PUT", "/txn1").fail(500, {
+                errcode: "M_SOMETHING",
+                error: "Ruh roh",
+            });
+            client.sendTextMessage("!foo:bar", "a body", "txn1").done(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").done(function(res) {
+                sentA = true;
+                expect(sentB).toBe(true);
+            });
+            client.sendTextMessage("!foo:bar", "b body", "txn2").done(function(res) {
+                sentB = true;
+                expect(sentA).toBe(false);
+            });
+            httpBackend.flush("/txn2", 1).done(function() {
+                httpBackend.flush("/txn1", 1).done(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").done(function(res) {
+                expect(res.event_id).toEqual("foo");
+                done();
+            });
+            httpBackend.flush("/txn1", 1);
+        });
+    });
+});
@@ -1,207 +0,0 @@
-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";
-
-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: "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: {},
-                            }),
-                        ],
-                    },
-                },
-            },
-        },
-    };
-
-    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");
-        });
-    });
-});
@@ -1,116 +0,0 @@
-/*
-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" });
-    });
-});
@@ -0,0 +1,128 @@
+"use strict";
+import 'source-map-support/register';
+import Promise from 'bluebird';
+
+const sdk = require("../..");
+const HttpBackend = require("matrix-mock-request");
+const utils = require("../test-utils");
+const EventStatus = sdk.EventStatus;
+
+import expect from 'expect';
+
+describe("MatrixClient retrying", function() {
+    const baseUrl = "http://localhost.or.something";
+    let client = null;
+    let httpBackend = null;
+    let scheduler;
+    const userId = "@alice:localhost";
+    const accessToken = "aseukfgwef";
+    const roomId = "!room:here";
+    let room;
+
+    beforeEach(function() {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
+        httpBackend = new HttpBackend();
+        sdk.request(httpBackend.requestFn);
+        scheduler = new sdk.MatrixScheduler();
+        client = sdk.createClient({
+            baseUrl: baseUrl,
+            userId: userId,
+            accessToken: accessToken,
+            scheduler: scheduler,
+        });
+        room = new sdk.Room(roomId);
+        client.store.storeRoom(room);
+    });
+
+    afterEach(function() {
+        httpBackend.verifyNoOutstandingExpectation();
+    });
+
+    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() {
+
+        });
+    });
+});
@@ -1,136 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import HttpBackend from "matrix-mock-request";
-
-import { EventStatus, RoomEvent, MatrixClient, MatrixScheduler } from "../../src/matrix";
-import { Room } from "../../src/models/room";
-import { TestClient } from "../TestClient";
-
-describe("MatrixClient retrying", function () {
-    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: "m.text",
-                body: "m1",
-            })
-            .then(
-                function () {
-                    // we expect the first message to fail
-                    throw new Error("Message 1 unexpectedly sent successfully");
-                },
-                () => {
-                    // this is expected
-                },
-            );
-
-        // XXX: it turns out that the promise returned by this message
-        // never gets resolved.
-        // https://github.com/matrix-org/matrix-js-sdk/issues/496
-        client!.sendMessage(roomId, {
-            msgtype: "m.text",
-            body: "m2",
-        });
-
-        // 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 () {});
-    });
-});
@@ -0,0 +1,613 @@
+"use strict";
+import 'source-map-support/register';
+const sdk = require("../..");
+const EventStatus = sdk.EventStatus;
+const HttpBackend = require("matrix-mock-request");
+const utils = require("../test-utils");
+
+import Promise from 'bluebird';
+import expect from 'expect';
+
+describe("MatrixClient room timelines", function() {
+    const baseUrl = "http://localhost.or.something";
+    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(done) {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
+        httpBackend = new HttpBackend();
+        sdk.request(httpBackend.requestFn);
+        client = sdk.createClient({
+            baseUrl: baseUrl,
+            userId: userId,
+            accessToken: accessToken,
+            // these tests should work with or without timelineSupport
+            timelineSupport: true,
+        });
+        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();
+        httpBackend.flush("/pushrules").then(function() {
+            return httpBackend.flush("/filter");
+        }).nodeify(done);
+    });
+
+    afterEach(function() {
+        httpBackend.verifyNoOutstandingExpectation();
+        client.stopClient();
+    });
+
+    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).done(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").done(
+                function() {
+                    expect(room.timeline[1].getId()).toEqual(eventId);
+                    httpBackend.flush("/sync", 1).done(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).done(function() {
+                    expect(room.timeline.length).toEqual(2);
+                    httpBackend.flush("/txn1", 1);
+                    promise.done(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).done(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).done(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).done(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).done(function() {
+                    expect(room.oldState.paginationToken).toEqual(sbEndTok);
+                });
+
+                httpBackend.flush("/messages", 1).done(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);
+                });
+            });
+        });
+    });
+});
@@ -1,872 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import HttpBackend from "matrix-mock-request";
-
-import * as utils from "../test-utils/test-utils";
-import { EventStatus } from "../../src/models/event";
-import {
-    MatrixError,
-    ClientEvent,
-    IEvent,
-    MatrixClient,
-    RoomEvent,
-    ISyncResponse,
-    IMinimalEvent,
-    IRoomEvent,
-    Room,
-} from "../../src";
-import { TestClient } from "../TestClient";
-
-describe("MatrixClient room timelines", function () {
-    const userId = "@alice:localhost";
-    const userName = "Alice";
-    const accessToken = "aseukfgwef";
-    const roomId = "!foo:bar";
-    const otherUserId = "@bob:localhost";
-    let client: MatrixClient | undefined;
-    let httpBackend: HttpBackend | undefined;
-
-    const USER_MEMBERSHIP_EVENT = utils.mkMembership({
-        room: roomId,
-        mship: "join",
-        user: userId,
-        name: userName,
-    });
-    const ROOM_NAME_EVENT = utils.mkEvent({
-        type: "m.room.name",
-        room: roomId,
-        user: otherUserId,
-        content: {
-            name: "Old room name",
-        },
-    });
-    let NEXT_SYNC_DATA: Partial<ISyncResponse>;
-    const SYNC_DATA = {
-        next_batch: "s_5_3",
-        rooms: {
-            join: {
-                "!foo:bar": {
-                    // roomId
-                    timeline: {
-                        events: [
-                            utils.mkMessage({
-                                room: roomId,
-                                user: otherUserId,
-                                msg: "hello",
-                            }),
-                        ],
-                        prev_batch: "f_1_1",
-                    },
-                    state: {
-                        events: [
-                            ROOM_NAME_EVENT,
-                            utils.mkMembership({
-                                room: roomId,
-                                mship: "join",
-                                user: otherUserId,
-                                name: "Bob",
-                            }),
-                            USER_MEMBERSHIP_EVENT,
-                            utils.mkEvent({
-                                type: "m.room.create",
-                                room: roomId,
-                                user: userId,
-                                content: {},
-                            }),
-                        ],
-                    },
-                },
-            },
-        },
-    };
-
-    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: "join",
-                user: userId,
-                room: roomId,
-                name: "Old Alice",
-                url: undefined,
-            });
-
-            // make an m.room.member event with prev_content for alice's nick
-            // change
-            const oldMshipEvent = utils.mkMembership({
-                mship: "join",
-                user: userId,
-                room: roomId,
-                name: userName,
-                url: "mxc://some/url",
-            });
-            oldMshipEvent.prev_content = {
-                displayname: "Old Alice",
-                avatar_url: undefined,
-                membership: "join",
-            };
-
-            // set the list of events to return on scrollback (/messages)
-            // N.B. synapse returns /messages in reverse chronological order
-            sbEvents = [
-                utils.mkMessage({
-                    user: userId,
-                    room: roomId,
-                    msg: "I'm alice",
-                }),
-                oldMshipEvent,
-                utils.mkMessage({
-                    user: userId,
-                    room: roomId,
-                    msg: "I'm old alice",
-                }),
-                joinMshipEvent,
-            ];
-
-            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: "join",
-                    name: "New Name",
-                }),
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(eventData);
-
-            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
-                const room = client!.getRoom(roomId)!;
-                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
-                    const preNameEvent = room.timeline[room.timeline.length - 3];
-                    const postNameEvent = room.timeline[room.timeline.length - 1];
-                    expect(preNameEvent.sender?.name).toEqual(userName);
-                    expect(postNameEvent.sender?.name).toEqual("New Name");
-                });
-            });
-        });
-
-        it("should set the right room.name", function () {
-            const secondRoomNameEvent = utils.mkEvent({
-                user: userId,
-                room: roomId,
-                type: "m.room.name",
-                content: {
-                    name: "Room 2",
-                },
-            });
-            setNextSyncData([secondRoomNameEvent]);
-
-            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
-                const room = client!.getRoom(roomId)!;
-                let nameEmitCount = 0;
-                client!.on(RoomEvent.Name, function (rm) {
-                    nameEmitCount += 1;
-                });
-
-                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)])
-                    .then(function () {
-                        expect(nameEmitCount).toEqual(1);
-                        expect(room.name).toEqual("Room 2");
-                        // do another round
-                        const thirdRoomNameEvent = utils.mkEvent({
-                            user: userId,
-                            room: roomId,
-                            type: "m.room.name",
-                            content: {
-                                name: "Room 3",
-                            },
-                        });
-                        setNextSyncData([thirdRoomNameEvent]);
-                        httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-                        return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]);
-                    })
-                    .then(function () {
-                        expect(nameEmitCount).toEqual(2);
-                        expect(room.name).toEqual("Room 3");
-                    });
-            });
-        });
-
-        it("should set the right room members", function () {
-            const userC = "@cee:bar";
-            const userD = "@dee:bar";
-            const eventData = [
-                utils.mkMembership({
-                    user: userC,
-                    room: roomId,
-                    mship: "join",
-                    name: "C",
-                }),
-                utils.mkMembership({
-                    user: userC,
-                    room: roomId,
-                    mship: "invite",
-                    skey: userD,
-                }),
-            ];
-            setNextSyncData(eventData);
-
-            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
-                const room = client!.getRoom(roomId)!;
-                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
-                    expect(room.currentState.getMembers().length).toEqual(4);
-                    expect(room.currentState.getMember(userC)!.name).toEqual("C");
-                    expect(room.currentState.getMember(userC)!.membership).toEqual("join");
-                    expect(room.currentState.getMember(userD)!.name).toEqual(userD);
-                    expect(room.currentState.getMember(userD)!.membership).toEqual("invite");
-                });
-            });
-        });
-    });
-
-    describe("gappy sync", function () {
-        it("should copy the last known state to the new timeline", function () {
-            const eventData = [utils.mkMessage({ user: userId, room: roomId })];
-            setNextSyncData(eventData);
-            NEXT_SYNC_DATA.rooms!.join[roomId].timeline.limited = true;
-
-            return Promise.all([
-                httpBackend!.flush("/versions", 1),
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
-                const room = client!.getRoom(roomId)!;
-
-                httpBackend!.flush("/messages", 1);
-                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
-                    expect(room.timeline.length).toEqual(1);
-                    expect(room.timeline[0].event).toEqual(eventData[0]);
-                    expect(room.currentState.getMembers().length).toEqual(2);
-                    expect(room.currentState.getMember(userId)!.name).toEqual(userName);
-                    expect(room.currentState.getMember(userId)!.membership).toEqual("join");
-                    expect(room.currentState.getMember(otherUserId)!.name).toEqual("Bob");
-                    expect(room.currentState.getMember(otherUserId)!.membership).toEqual("join");
-                });
-            });
-        });
-
-        it("should emit a `RoomEvent.TimelineReset` event when the sync response is `limited`", function () {
-            const eventData = [utils.mkMessage({ user: userId, room: roomId })];
-            setNextSyncData(eventData);
-            NEXT_SYNC_DATA.rooms!.join[roomId].timeline.limited = true;
-
-            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
-                const room = client!.getRoom(roomId)!;
-
-                let emitCount = 0;
-                client!.on(RoomEvent.TimelineReset, function (emitRoom) {
-                    expect(emitRoom).toEqual(room);
-                    emitCount++;
-                });
-
-                httpBackend!.flush("/messages", 1);
-                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
-                    expect(emitCount).toEqual(1);
-                });
-            });
-        });
-    });
-
-    describe("Refresh live timeline", () => {
-        const initialSyncEventData = [
-            utils.mkMessage({ user: userId, room: roomId }),
-            utils.mkMessage({ user: userId, room: roomId }),
-            utils.mkMessage({ user: userId, room: roomId }),
-        ];
-
-        const contextUrl =
-            `/rooms/${encodeURIComponent(roomId)}/context/` +
-            `${encodeURIComponent(initialSyncEventData[2].event_id!)}`;
-        const contextResponse = {
-            start: "start_token",
-            events_before: [initialSyncEventData[1], initialSyncEventData[0]],
-            event: initialSyncEventData[2],
-            events_after: [],
-            state: [USER_MEMBERSHIP_EVENT],
-            end: "end_token",
-        };
-
-        let room: Room;
-        beforeEach(async () => {
-            setNextSyncData(initialSyncEventData);
-
-            // Create a room from the sync
-            await Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 1)]);
-
-            // Get the room after the first sync so the room is created
-            room = client!.getRoom(roomId)!;
-            expect(room).toBeTruthy();
-        });
-
-        it("should clear and refresh messages in timeline", async () => {
-            // `/context` request for `refreshLiveTimeline()` -> `getEventTimeline()`
-            // to construct a new timeline from.
-            httpBackend!.when("GET", contextUrl).respond(200, function () {
-                // The timeline should be cleared at this point in the refresh
-                expect(room.timeline.length).toEqual(0);
-
-                return contextResponse;
-            });
-
-            // Refresh the timeline.
-            await Promise.all([room.refreshLiveTimeline(), httpBackend!.flushAllExpected()]);
-
-            // Make sure the message are visible
-            const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
-            const resultantEventIdsInTimeline = resultantEventsInTimeline.map((event) => event.getId());
-            expect(resultantEventIdsInTimeline).toEqual([
-                initialSyncEventData[0].event_id,
-                initialSyncEventData[1].event_id,
-                initialSyncEventData[2].event_id,
-            ]);
-        });
-
-        it("Perfectly merges timelines if a sync finishes while refreshing the timeline", async () => {
-            // `/context` request for `refreshLiveTimeline()` ->
-            // `getEventTimeline()` to construct a new timeline from.
-            //
-            // We only resolve this request after we detect that the timeline
-            // was reset(when it goes blank) and force a sync to happen in the
-            // middle of all of this refresh timeline logic. We want to make
-            // sure the sync pagination still works as expected after messing
-            // the refresh timline logic messes with the pagination tokens.
-            httpBackend!.when("GET", contextUrl).respond(200, () => {
-                // Now finally return and make the `/context` request respond
-                return contextResponse;
-            });
-
-            // Wait for the timeline to reset(when it goes blank) which means
-            // it's in the middle of the refrsh logic right before the
-            // `getEventTimeline()` -> `/context`. Then simulate a racey `/sync`
-            // to happen in the middle of all of this refresh timeline logic. We
-            // want to make sure the sync pagination still works as expected
-            // after messing the refresh timline logic messes with the
-            // pagination tokens.
-            //
-            // We define this here so the event listener is in place before we
-            // call `room.refreshLiveTimeline()`.
-            const racingSyncEventData = [utils.mkMessage({ user: userId, room: roomId })];
-            const waitForRaceySyncAfterResetPromise = new Promise<void>((resolve, reject) => {
-                let eventFired = false;
-                // Throw a more descriptive error if this part of the test times out.
-                const failTimeout = setTimeout(() => {
-                    if (eventFired) {
-                        reject(
-                            new Error(
-                                "TestError: `RoomEvent.TimelineReset` fired but we timed out trying to make" +
-                                    "a `/sync` happen in time.",
-                            ),
-                        );
-                    } else {
-                        reject(new Error("TestError: Timed out while waiting for `RoomEvent.TimelineReset` to fire."));
-                    }
-                }, 4000 /* FIXME: Is there a way to reference the current timeout of this test in Jest? */);
-
-                room.on(RoomEvent.TimelineReset, async () => {
-                    try {
-                        eventFired = true;
-
-                        // The timeline should be cleared at this point in the refresh
-                        expect(room.getUnfilteredTimelineSet().getLiveTimeline().getEvents().length).toEqual(0);
-
-                        // Then make a `/sync` happen by sending a message and seeing that it
-                        // shows up (simulate a /sync naturally racing with us).
-                        setNextSyncData(racingSyncEventData);
-                        httpBackend!.when("GET", "/sync").respond(200, function () {
-                            return NEXT_SYNC_DATA;
-                        });
-                        await Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!, 1)]);
-                        // Make sure the timeline has the racey sync data
-                        const afterRaceySyncTimelineEvents = room
-                            .getUnfilteredTimelineSet()
-                            .getLiveTimeline()
-                            .getEvents();
-                        const afterRaceySyncTimelineEventIds = afterRaceySyncTimelineEvents.map((event) =>
-                            event.getId(),
-                        );
-                        expect(afterRaceySyncTimelineEventIds).toEqual([racingSyncEventData[0].event_id]);
-
-                        clearTimeout(failTimeout);
-                        resolve();
-                    } catch (err) {
-                        reject(err);
-                    }
-                });
-            });
-
-            // Refresh the timeline. Just start the function, we will wait for
-            // it to finish after the racey sync.
-            const refreshLiveTimelinePromise = room.refreshLiveTimeline();
-
-            await waitForRaceySyncAfterResetPromise;
-
-            await Promise.all([
-                refreshLiveTimelinePromise,
-                // Then flush the remaining `/context` to left the refresh logic complete
-                httpBackend!.flushAllExpected(),
-            ]);
-
-            // Make sure sync pagination still works by seeing a new message show up
-            // after refreshing the timeline.
-            const afterRefreshEventData = [utils.mkMessage({ user: userId, room: roomId })];
-            setNextSyncData(afterRefreshEventData);
-            httpBackend!.when("GET", "/sync").respond(200, function () {
-                return NEXT_SYNC_DATA;
-            });
-            await Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 1)]);
-
-            // Make sure the timeline includes the the events from the `/sync`
-            // that raced and beat us in the middle of everything and the
-            // `/sync` after the refresh. Since the `/sync` beat us to create
-            // the timeline, `initialSyncEventData` won't be visible unless we
-            // paginate backwards with `/messages`.
-            const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
-            const resultantEventIdsInTimeline = resultantEventsInTimeline.map((event) => event.getId());
-            expect(resultantEventIdsInTimeline).toEqual([
-                racingSyncEventData[0].event_id,
-                afterRefreshEventData[0].event_id,
-            ]);
-        });
-
-        it("Timeline recovers after `/context` request to generate new timeline fails", async () => {
-            // `/context` request for `refreshLiveTimeline()` -> `getEventTimeline()`
-            // to construct a new timeline from.
-            httpBackend!
-                .when("GET", contextUrl)
-                .check(() => {
-                    // The timeline should be cleared at this point in the refresh
-                    expect(room.timeline.length).toEqual(0);
-                })
-                .respond(
-                    500,
-                    new MatrixError({
-                        errcode: "TEST_FAKE_ERROR",
-                        error:
-                            "We purposely intercepted this /context request to make it fail " +
-                            "in order to test whether the refresh timeline code is resilient",
-                    }),
-                );
-
-            // Refresh the timeline and expect it to fail
-            const settledFailedRefreshPromises = await Promise.allSettled([
-                room.refreshLiveTimeline(),
-                httpBackend!.flushAllExpected(),
-            ]);
-            // We only expect `TEST_FAKE_ERROR` here. Anything else is
-            // unexpected and should fail the test.
-            if (settledFailedRefreshPromises[0].status === "fulfilled") {
-                throw new Error("Expected the /context request to fail with a 500");
-            } else if (settledFailedRefreshPromises[0].reason.errcode !== "TEST_FAKE_ERROR") {
-                throw settledFailedRefreshPromises[0].reason;
-            }
-
-            // The timeline will be empty after we refresh the timeline and fail
-            // to construct a new timeline.
-            expect(room.timeline.length).toEqual(0);
-
-            // `/messages` request for `refreshLiveTimeline()` ->
-            // `getLatestTimeline()` to construct a new timeline from.
-            httpBackend!.when("GET", `/rooms/${encodeURIComponent(roomId)}/messages`).respond(200, function () {
-                return {
-                    chunk: [
-                        {
-                            // The latest message in the room
-                            event_id: initialSyncEventData[2].event_id,
-                        },
-                    ],
-                };
-            });
-            // `/context` request for `refreshLiveTimeline()` ->
-            // `getLatestTimeline()` -> `getEventTimeline()` to construct a new
-            // timeline from.
-            httpBackend!.when("GET", contextUrl).respond(200, function () {
-                // The timeline should be cleared at this point in the refresh
-                expect(room.timeline.length).toEqual(0);
-
-                return contextResponse;
-            });
-
-            // Refresh the timeline again but this time it should pass
-            await Promise.all([room.refreshLiveTimeline(), httpBackend!.flushAllExpected()]);
-
-            // Make sure sync pagination still works by seeing a new message show up
-            // after refreshing the timeline.
-            const afterRefreshEventData = [utils.mkMessage({ user: userId, room: roomId })];
-            setNextSyncData(afterRefreshEventData);
-            httpBackend!.when("GET", "/sync").respond(200, function () {
-                return NEXT_SYNC_DATA;
-            });
-            await Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 1)]);
-
-            // Make sure the message are visible
-            const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
-            const resultantEventIdsInTimeline = resultantEventsInTimeline.map((event) => event.getId());
-            expect(resultantEventIdsInTimeline).toEqual([
-                initialSyncEventData[0].event_id,
-                initialSyncEventData[1].event_id,
-                initialSyncEventData[2].event_id,
-                afterRefreshEventData[0].event_id,
-            ]);
-        });
-    });
-});
@@ -0,0 +1,739 @@
+"use strict";
+import 'source-map-support/register';
+const sdk = require("../..");
+const HttpBackend = require("matrix-mock-request");
+const utils = require("../test-utils");
+const MatrixEvent = sdk.MatrixEvent;
+const EventTimeline = sdk.EventTimeline;
+
+import expect from 'expect';
+import Promise from 'bluebird';
+
+describe("MatrixClient syncing", function() {
+    const baseUrl = "http://localhost.or.something";
+    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() {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
+        httpBackend = new HttpBackend();
+        sdk.request(httpBackend.requestFn);
+        client = sdk.createClient({
+            baseUrl: baseUrl,
+            userId: selfUserId,
+            accessToken: selfAccessToken,
+        });
+        httpBackend.when("GET", "/pushrules").respond(200, {});
+        httpBackend.when("POST", "/filter").respond(200, { filter_id: "a filter id" });
+    });
+
+    afterEach(function() {
+        httpBackend.verifyNoOutstandingExpectation();
+        client.stopClient();
+    });
+
+    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().done(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().done(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);
+            });
+        });
+
+        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).toExist();
+                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 defer = Promise.defer();
+
+            httpBackend.when("GET", "/sync").check(function(req) {
+                expect(req.queryParams.filter).toEqual("another_id");
+                defer.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();
+                }),
+                defer.promise,
+            ]);
+        });
+
+        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);
+    }
+});
@@ -1,383 +0,0 @@
-/*
-Copyright 2023 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import "fake-indexeddb/auto";
-
-import HttpBackend from "matrix-mock-request";
-
-import {
-    Category,
-    ClientEvent,
-    EventType,
-    ISyncResponse,
-    MatrixClient,
-    MatrixEvent,
-    NotificationCountType,
-    RelationType,
-    Room,
-} from "../../src";
-import { TestClient } from "../TestClient";
-import { ReceiptType } from "../../src/@types/read_receipts";
-import { mkThread } from "../test-utils/thread";
-import { SyncState } from "../../src/sync";
-
-describe("MatrixClient syncing", () => {
-    const userA = "@alice:localhost";
-    const userB = "@bob:localhost";
-
-    const selfUserId = userA;
-    const selfAccessToken = "aseukfgwef";
-
-    let client: MatrixClient | undefined;
-    let httpBackend: HttpBackend | undefined;
-
-    const setupTestClient = (): [MatrixClient, HttpBackend] => {
-        const testClient = new TestClient(selfUserId, "DEVICE", selfAccessToken);
-        const httpBackend = testClient.httpBackend;
-        const client = testClient.client;
-        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(() => {
-        [client, httpBackend] = setupTestClient();
-    });
-
-    afterEach(() => {
-        httpBackend!.verifyNoOutstandingExpectation();
-        client!.stopClient();
-        return httpBackend!.stop();
-    });
-
-    it("reactions in thread set the correct timeline to unread", async () => {
-        const roomId = "!room:localhost";
-
-        // start the client, and wait for it to initialise
-        httpBackend!.when("GET", "/sync").respond(200, {
-            next_batch: "s_5_3",
-            rooms: {
-                [Category.Join]: {},
-                [Category.Leave]: {},
-                [Category.Invite]: {},
-            },
-        });
-        client!.startClient({ threadSupport: true });
-        await Promise.all([
-            httpBackend?.flushAllExpected(),
-            new Promise<void>((resolve) => {
-                client!.on(ClientEvent.Sync, (state) => state === SyncState.Syncing && resolve());
-            }),
-        ]);
-
-        const room = new Room(roomId, client!, selfUserId);
-        jest.spyOn(client!, "getRoom").mockImplementation((id) => (id === roomId ? room : null));
-
-        const thread = mkThread({ room, client: client!, authorId: selfUserId, participantUserIds: [selfUserId] });
-        const threadReply = thread.events.at(-1)!;
-        await room.addLiveEvents([thread.rootEvent]);
-
-        // Initialize read receipt datastructure before testing the reaction
-        room.addReceiptToStructure(thread.rootEvent.getId()!, ReceiptType.Read, selfUserId, { ts: 1 }, false);
-        thread.thread.addReceiptToStructure(
-            threadReply.getId()!,
-            ReceiptType.Read,
-            selfUserId,
-            { thread_id: thread.thread.id, ts: 1 },
-            false,
-        );
-        expect(room.getReadReceiptForUserId(selfUserId, false)?.eventId).toEqual(thread.rootEvent.getId());
-        expect(thread.thread.getReadReceiptForUserId(selfUserId, false)?.eventId).toEqual(threadReply.getId());
-
-        const reactionEventId = `$9-${Math.random()}-${Math.random()}`;
-        let lastEvent: MatrixEvent | null = null;
-        jest.spyOn(client! as any, "sendEventHttpRequest").mockImplementation((event) => {
-            lastEvent = event as MatrixEvent;
-            return { event_id: reactionEventId };
-        });
-
-        await client!.sendEvent(roomId, EventType.Reaction, {
-            "m.relates_to": {
-                rel_type: RelationType.Annotation,
-                event_id: threadReply.getId(),
-                key: "",
-            },
-        });
-
-        expect(lastEvent!.getId()).toEqual(reactionEventId);
-        room.handleRemoteEcho(new MatrixEvent(lastEvent!.event), lastEvent!);
-
-        // Our ideal state after this is the following:
-        //
-        // Room: [synthetic: threadroot, actual: threadroot]
-        // Thread: [synthetic: threadreaction, actual: threadreply]
-        //
-        // The reaction and reply are both in the thread, and their receipts should be isolated to the thread.
-        // The reaction has not been acknowledged in a dedicated read receipt message, so only the synthetic receipt
-        // should be updated.
-
-        // Ensure the synthetic receipt for the room has not been updated
-        expect(room.getReadReceiptForUserId(selfUserId, false)?.eventId).toEqual(thread.rootEvent.getId());
-        expect(room.getEventReadUpTo(selfUserId, false)).toEqual(thread.rootEvent.getId());
-        // Ensure the actual receipt for the room has not been updated
-        expect(room.getReadReceiptForUserId(selfUserId, true)?.eventId).toEqual(thread.rootEvent.getId());
-        expect(room.getEventReadUpTo(selfUserId, true)).toEqual(thread.rootEvent.getId());
-        // Ensure the synthetic receipt for the thread has been updated
-        expect(thread.thread.getReadReceiptForUserId(selfUserId, false)?.eventId).toEqual(reactionEventId);
-        expect(thread.thread.getEventReadUpTo(selfUserId, false)).toEqual(reactionEventId);
-        // Ensure the actual receipt for the thread has not been updated
-        expect(thread.thread.getReadReceiptForUserId(selfUserId, true)?.eventId).toEqual(threadReply.getId());
-        expect(thread.thread.getEventReadUpTo(selfUserId, true)).toEqual(threadReply.getId());
-    });
-
-    describe("Stuck unread notifications integration tests", () => {
-        const ROOM_ID = "!room:localhost";
-
-        const syncData = getSampleStuckNotificationSyncResponse(ROOM_ID);
-
-        it("resets notifications if the last event originates from the logged in user", async () => {
-            httpBackend!
-                .when("GET", "/sync")
-                .check((req) => {
-                    expect(req.queryParams!.filter).toEqual("a filter id");
-                })
-                .respond(200, syncData);
-
-            client!.store.getSavedSyncToken = jest.fn().mockResolvedValue("this-is-a-token");
-            client!.startClient({ initialSyncLimit: 1 });
-
-            await httpBackend!.flushAllExpected();
-
-            const room = client?.getRoom(ROOM_ID);
-
-            expect(room).toBeInstanceOf(Room);
-            expect(room?.getUnreadNotificationCount(NotificationCountType.Total)).toBe(0);
-        });
-    });
-
-    function getSampleStuckNotificationSyncResponse(roomId: string): Partial<ISyncResponse> {
-        return {
-            next_batch: "batch_token",
-            rooms: {
-                [Category.Join]: {
-                    [roomId]: {
-                        timeline: {
-                            events: [
-                                {
-                                    content: {
-                                        room_version: "9",
-                                    },
-                                    origin_server_ts: 1,
-                                    sender: userB,
-                                    state_key: "",
-                                    type: "m.room.create",
-                                    event_id: "$event1",
-                                },
-                                {
-                                    content: {
-                                        avatar_url: "",
-                                        displayname: userB,
-                                        membership: "join",
-                                    },
-                                    origin_server_ts: 2,
-                                    sender: userB,
-                                    state_key: userB,
-                                    type: "m.room.member",
-                                    event_id: "$event2",
-                                },
-                                {
-                                    content: {
-                                        ban: 50,
-                                        events: {
-                                            "m.room.avatar": 50,
-                                            "m.room.canonical_alias": 50,
-                                            "m.room.encryption": 100,
-                                            "m.room.history_visibility": 100,
-                                            "m.room.name": 50,
-                                            "m.room.power_levels": 100,
-                                            "m.room.server_acl": 100,
-                                            "m.room.tombstone": 100,
-                                        },
-                                        events_default: 0,
-                                        historical: 100,
-                                        invite: 0,
-                                        kick: 50,
-                                        redact: 50,
-                                        state_default: 50,
-                                        users: {
-                                            [userA]: 100,
-                                            [userB]: 100,
-                                        },
-                                        users_default: 0,
-                                    },
-                                    origin_server_ts: 3,
-                                    sender: userB,
-                                    state_key: "",
-                                    type: "m.room.power_levels",
-                                    event_id: "$event3",
-                                },
-                                {
-                                    content: {
-                                        join_rule: "invite",
-                                    },
-                                    origin_server_ts: 4,
-                                    sender: userB,
-                                    state_key: "",
-                                    type: "m.room.join_rules",
-                                    event_id: "$event4",
-                                },
-                                {
-                                    content: {
-                                        history_visibility: "shared",
-                                    },
-                                    origin_server_ts: 5,
-                                    sender: userB,
-                                    state_key: "",
-                                    type: "m.room.history_visibility",
-                                    event_id: "$event5",
-                                },
-                                {
-                                    content: {
-                                        guest_access: "can_join",
-                                    },
-                                    origin_server_ts: 6,
-                                    sender: userB,
-                                    state_key: "",
-                                    type: "m.room.guest_access",
-                                    unsigned: {
-                                        age: 1651569,
-                                    },
-                                    event_id: "$event6",
-                                },
-                                {
-                                    content: {
-                                        algorithm: "m.megolm.v1.aes-sha2",
-                                    },
-                                    origin_server_ts: 7,
-                                    sender: userB,
-                                    state_key: "",
-                                    type: "m.room.encryption",
-                                    event_id: "$event7",
-                                },
-                                {
-                                    content: {
-                                        avatar_url: "",
-                                        displayname: userA,
-                                        is_direct: true,
-                                        membership: "invite",
-                                    },
-                                    origin_server_ts: 8,
-                                    sender: userB,
-                                    state_key: userA,
-                                    type: "m.room.member",
-                                    event_id: "$event8",
-                                },
-                                {
-                                    content: {
-                                        msgtype: "m.text",
-                                        body: "hello",
-                                    },
-                                    origin_server_ts: 9,
-                                    sender: userB,
-                                    type: "m.room.message",
-                                    event_id: "$event9",
-                                },
-                                {
-                                    content: {
-                                        avatar_url: "",
-                                        displayname: userA,
-                                        membership: "join",
-                                    },
-                                    origin_server_ts: 10,
-                                    sender: userA,
-                                    state_key: userA,
-                                    type: "m.room.member",
-                                    event_id: "$event10",
-                                },
-                                {
-                                    content: {
-                                        msgtype: "m.text",
-                                        body: "world",
-                                    },
-                                    origin_server_ts: 11,
-                                    sender: userA,
-                                    type: "m.room.message",
-                                    event_id: "$event11",
-                                },
-                            ],
-                            prev_batch: "123",
-                            limited: false,
-                        },
-                        state: {
-                            events: [],
-                        },
-                        account_data: {
-                            events: [
-                                {
-                                    type: "m.fully_read",
-                                    content: {
-                                        event_id: "$dER5V1RCMxzAhHXQJoMjqyuoxpPtK2X6hCb9T8Jg2wU",
-                                    },
-                                },
-                            ],
-                        },
-                        ephemeral: {
-                            events: [
-                                {
-                                    type: "m.receipt",
-                                    content: {
-                                        $event9: {
-                                            "m.read": {
-                                                [userA]: {
-                                                    ts: 100,
-                                                },
-                                            },
-                                            "m.read.private": {
-                                                [userA]: {
-                                                    ts: 100,
-                                                },
-                                            },
-                                        },
-                                        dER5V1RCMxzAhHXQJoMjqyuoxpPtK2X6hCb9T8Jg2wU: {
-                                            "m.read": {
-                                                [userB]: {
-                                                    ts: 666,
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            ],
-                        },
-                        unread_notifications: {
-                            notification_count: 1,
-                            highlight_count: 0,
-                        },
-                        summary: {
-                            "m.joined_member_count": 2,
-                            "m.invited_member_count": 0,
-                            "m.heroes": [userB],
-                        },
-                    },
-                },
-                [Category.Leave]: {},
-                [Category.Invite]: {},
-                [Category.Knock]: {},
-            },
-        };
-    }
-});
@@ -0,0 +1,962 @@
+/*
+Copyright 2016 OpenMarket 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.
+*/
+
+"use strict";
+
+const anotherjson = require('another-json');
+import Promise from 'bluebird';
+import expect from 'expect';
+
+const utils = require('../../lib/utils');
+const testUtils = require('../test-utils');
+const TestClient = require('../TestClient').default;
+
+const ROOM_ID = "!room:id";
+
+/**
+ * start an Olm session with a given recipient
+ *
+ * @param {Olm.Account} olmAccount
+ * @param {TestClient} recipientTestClient
+ * @return {Promise} promise for Olm.Session
+ */
+function createOlmSession(olmAccount, recipientTestClient) {
+    return recipientTestClient.awaitOneTimeKeyUpload().then((keys) => {
+        const otkId = utils.keys(keys)[0];
+        const otk = keys[otkId];
+
+        const session = new global.Olm.Session();
+        session.create_outbound(
+            olmAccount, recipientTestClient.getDeviceKey(), otk.key,
+        );
+        return session;
+    });
+}
+
+/**
+ * encrypt an event with olm
+ *
+ * @param {object} opts
+ * @param {string=} opts.sender
+ * @param {string} opts.senderKey
+ * @param {Olm.Session} opts.p2pSession
+ * @param {TestClient} opts.recipient
+ * @param {object=} opts.plaincontent
+ * @param {string=} opts.plaintype
+ *
+ * @return {object} event
+ */
+function encryptOlmEvent(opts) {
+    expect(opts.senderKey).toBeTruthy();
+    expect(opts.p2pSession).toBeTruthy();
+    expect(opts.recipient).toBeTruthy();
+
+    const plaintext = {
+        content: opts.plaincontent || {},
+        recipient: opts.recipient.userId,
+        recipient_keys: {
+            ed25519: opts.recipient.getSigningKey(),
+        },
+        sender: opts.sender || '@bob:xyz',
+        type: opts.plaintype || 'm.test',
+    };
+
+    const event = {
+        content: {
+            algorithm: 'm.olm.v1.curve25519-aes-sha2',
+            ciphertext: {},
+            sender_key: opts.senderKey,
+        },
+        sender: opts.sender || '@bob:xyz',
+        type: 'm.room.encrypted',
+    };
+    event.content.ciphertext[opts.recipient.getDeviceKey()] =
+        opts.p2pSession.encrypt(JSON.stringify(plaintext));
+    return event;
+}
+
+/**
+ * encrypt an event with megolm
+ *
+ * @param {object} opts
+ * @param {string} opts.senderKey
+ * @param {Olm.OutboundGroupSession} opts.groupSession
+ * @param {object=} opts.plaintext
+ * @param {string=} opts.room_id
+ *
+ * @return {object} event
+ */
+function encryptMegolmEvent(opts) {
+    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 {
+        event_id: 'test_megolm_event',
+        content: {
+            algorithm: "m.megolm.v1.aes-sha2",
+            ciphertext: opts.groupSession.encrypt(JSON.stringify(plaintext)),
+            device_id: "testDevice",
+            sender_key: opts.senderKey,
+            session_id: opts.groupSession.session_id(),
+        },
+        type: "m.room.encrypted",
+    };
+}
+
+/**
+ * build an encrypted room_key event to share a group session
+ *
+ * @param {object} opts
+ * @param {string} opts.senderKey
+ * @param {TestClient} opts.recipient
+ * @param {Olm.Session} opts.p2pSession
+ * @param {Olm.OutboundGroupSession} opts.groupSession
+ * @param {string=} opts.room_id
+ *
+ * @return {object} event
+ */
+function encryptGroupSessionKey(opts) {
+    return encryptOlmEvent({
+        senderKey: opts.senderKey,
+        recipient: opts.recipient,
+        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',
+    });
+}
+
+/**
+ * get a /sync response which contains a single room (ROOM_ID),
+ * with the members given
+ *
+ * @param {string[]} roomMembers
+ *
+ * @return {object} event
+ */
+function getSyncResponse(roomMembers) {
+    const roomResponse = {
+        state: {
+            events: [
+                testUtils.mkEvent({
+                    type: 'm.room.encryption',
+                    skey: '',
+                    content: {
+                        algorithm: 'm.megolm.v1.aes-sha2',
+                    },
+                }),
+            ],
+        },
+    };
+
+    for (let i = 0; i < roomMembers.length; i++) {
+        roomResponse.state.events.push(
+            testUtils.mkMembership({
+                mship: 'join',
+                sender: roomMembers[i],
+            }),
+        );
+    }
+
+    const syncResponse = {
+        next_batch: 1,
+        rooms: {
+            join: {},
+        },
+    };
+    syncResponse.rooms.join[ROOM_ID] = roomResponse;
+    return syncResponse;
+}
+
+
+describe("megolm", function() {
+    if (!global.Olm) {
+        console.warn('not running megolm tests: Olm not present');
+        return;
+    }
+    const Olm = global.Olm;
+
+    let testOlmAccount;
+    let testSenderKey;
+    let aliceTestClient;
+
+    /**
+     * Get the device keys for testOlmAccount in a format suitable for a
+     * response to /keys/query
+     *
+     * @param {string} userId The user ID to query for
+     * @returns {Object} The fake query response
+     */
+    function getTestKeysQueryResponse(userId) {
+        const testE2eKeys = JSON.parse(testOlmAccount.identity_keys());
+        const testDeviceKeys = {
+            algorithms: ['m.olm.v1.curve25519-aes-sha2', 'm.megolm.v1.aes-sha2'],
+            device_id: 'DEVICE_ID',
+            keys: {
+                'curve25519:DEVICE_ID': testE2eKeys.curve25519,
+                'ed25519:DEVICE_ID': testE2eKeys.ed25519,
+            },
+            user_id: userId,
+        };
+        const j = anotherjson.stringify(testDeviceKeys);
+        const sig = testOlmAccount.sign(j);
+        testDeviceKeys.signatures = {};
+        testDeviceKeys.signatures[userId] = {
+            'ed25519:DEVICE_ID': sig,
+        };
+
+        const queryResponse = {
+            device_keys: {},
+        };
+
+        queryResponse.device_keys[userId] = {
+            'DEVICE_ID': testDeviceKeys,
+        };
+
+        return queryResponse;
+    }
+
+    /**
+     * Get a one-time key for testOlmAccount in a format suitable for a
+     * response to /keys/claim
+
+     * @param {string} userId The user ID to query for
+     * @returns {Object} The fake key claim response
+     */
+    function getTestKeysClaimResponse(userId) {
+        testOlmAccount.generate_one_time_keys(1);
+        const testOneTimeKeys = JSON.parse(testOlmAccount.one_time_keys());
+        testOlmAccount.mark_keys_as_published();
+
+        const keyId = utils.keys(testOneTimeKeys.curve25519)[0];
+        const oneTimeKey = testOneTimeKeys.curve25519[keyId];
+        const keyResult = {
+            'key': oneTimeKey,
+        };
+        const j = anotherjson.stringify(keyResult);
+        const sig = testOlmAccount.sign(j);
+        keyResult.signatures = {};
+        keyResult.signatures[userId] = {
+            'ed25519:DEVICE_ID': sig,
+        };
+
+        const claimResponse = {one_time_keys: {}};
+        claimResponse.one_time_keys[userId] = {
+            'DEVICE_ID': {},
+        };
+        claimResponse.one_time_keys[userId].DEVICE_ID['signed_curve25519:' + keyId] =
+            keyResult;
+        return claimResponse;
+    }
+
+    beforeEach(async function() {
+        testUtils.beforeEach(this); // eslint-disable-line no-invalid-this
+
+        aliceTestClient = new TestClient(
+            "@alice:localhost", "xzcvb", "akjgkrgjs",
+        );
+        await aliceTestClient.client.initCrypto();
+
+        testOlmAccount = new Olm.Account();
+        testOlmAccount.create();
+        const testE2eKeys = JSON.parse(testOlmAccount.identity_keys());
+        testSenderKey = testE2eKeys.curve25519;
+    });
+
+    afterEach(function() {
+        aliceTestClient.stop();
+    });
+
+    it("Alice receives a megolm message", function() {
+        return aliceTestClient.start().then(() => {
+            return createOlmSession(testOlmAccount, aliceTestClient);
+        }).then((p2pSession) => {
+            const groupSession = new Olm.OutboundGroupSession();
+            groupSession.create();
+
+            // make the room_key event
+            const roomKeyEncrypted = encryptGroupSessionKey({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            // encrypt a message with the group session
+            const messageEncrypted = encryptMegolmEvent({
+                senderKey: testSenderKey,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            // Alice gets both the events in a single sync
+            const syncResponse = {
+                next_batch: 1,
+                to_device: {
+                    events: [roomKeyEncrypted],
+                },
+                rooms: {
+                    join: {},
+                },
+            };
+            syncResponse.rooms.join[ROOM_ID] = {
+                timeline: {
+                    events: [messageEncrypted],
+                },
+            };
+
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            const room = aliceTestClient.client.getRoom(ROOM_ID);
+            const event = room.getLiveTimeline().getEvents()[0];
+            expect(event.isEncrypted()).toBe(true);
+            return testUtils.awaitDecryption(event);
+        }).then((event) => {
+            expect(event.getContent().body).toEqual('42');
+        });
+    });
+
+    it("Alice receives a megolm message before the session keys", function() {
+        // https://github.com/vector-im/riot-web/issues/2273
+        let roomKeyEncrypted;
+
+        return aliceTestClient.start().then(() => {
+            return createOlmSession(testOlmAccount, aliceTestClient);
+        }).then((p2pSession) => {
+            const groupSession = new Olm.OutboundGroupSession();
+            groupSession.create();
+
+            // make the room_key event, but don't send it yet
+            roomKeyEncrypted = encryptGroupSessionKey({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            // encrypt a message with the group session
+            const messageEncrypted = encryptMegolmEvent({
+                senderKey: testSenderKey,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            // Alice just gets the message event to start with
+            const syncResponse = {
+                next_batch: 1,
+                rooms: {
+                    join: {},
+                },
+            };
+            syncResponse.rooms.join[ROOM_ID] = {
+                timeline: {
+                    events: [messageEncrypted],
+                },
+            };
+
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            const room = aliceTestClient.client.getRoom(ROOM_ID);
+            const event = room.getLiveTimeline().getEvents()[0];
+            expect(event.getContent().msgtype).toEqual('m.bad.encrypted');
+
+            // now she gets the room_key event
+            const syncResponse = {
+                next_batch: 2,
+                to_device: {
+                    events: [roomKeyEncrypted],
+                },
+            };
+
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            const room = aliceTestClient.client.getRoom(ROOM_ID);
+            const event = room.getLiveTimeline().getEvents()[0];
+
+            if (event.getContent().msgtype != 'm.bad.encrypted') {
+                return event;
+            }
+
+            return new Promise((resolve, reject) => {
+                event.once('Event.decrypted', (ev) => {
+                    console.log(`${Date.now()} event ${event.getId()} now decrypted`);
+                    resolve(ev);
+                });
+            });
+        }).then((event) => {
+            expect(event.getContent().body).toEqual('42');
+        });
+    });
+
+    it("Alice gets a second room_key message", function() {
+        return aliceTestClient.start().then(() => {
+            return createOlmSession(testOlmAccount, aliceTestClient);
+        }).then((p2pSession) => {
+            const groupSession = new Olm.OutboundGroupSession();
+            groupSession.create();
+
+            // make the room_key event
+            const roomKeyEncrypted1 = encryptGroupSessionKey({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            // encrypt a message with the group session
+            const messageEncrypted = encryptMegolmEvent({
+                senderKey: testSenderKey,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            // make a second room_key event now that we have advanced the group
+            // session.
+            const roomKeyEncrypted2 = encryptGroupSessionKey({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            // on the first sync, send the best room key
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
+                next_batch: 1,
+                to_device: {
+                    events: [roomKeyEncrypted1],
+                },
+            });
+
+            // on the second sync, send the advanced room key, along with the
+            // message.  This simulates the situation where Alice has been sent a
+            // later copy of the room key and is reloading the client.
+            const syncResponse2 = {
+                next_batch: 2,
+                to_device: {
+                    events: [roomKeyEncrypted2],
+                },
+                rooms: {
+                    join: {},
+                },
+            };
+            syncResponse2.rooms.join[ROOM_ID] = {
+                timeline: {
+                    events: [messageEncrypted],
+                },
+            };
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse2);
+
+            // flush both syncs
+            return aliceTestClient.flushSync().then(() => {
+                return aliceTestClient.flushSync();
+            });
+        }).then(function() {
+            const room = aliceTestClient.client.getRoom(ROOM_ID);
+            const event = room.getLiveTimeline().getEvents()[0];
+            expect(event.getContent().body).toEqual('42');
+        });
+    });
+
+    it('Alice sends a megolm message', function() {
+        let p2pSession;
+
+        return aliceTestClient.start().then(() => {
+            // establish an olm session with alice
+            return createOlmSession(testOlmAccount, aliceTestClient);
+        }).then((_p2pSession) => {
+            p2pSession = _p2pSession;
+
+            const syncResponse = getSyncResponse(['@bob:xyz']);
+
+            const olmEvent = encryptOlmEvent({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+            });
+
+            syncResponse.to_device = { events: [olmEvent] };
+
+            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            // start out with the device unknown - the send should be rejected.
+            aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
+                200, getTestKeysQueryResponse('@bob:xyz'),
+            );
+
+            return Promise.all([
+                aliceTestClient.client.sendTextMessage(ROOM_ID, 'test').then(() => {
+                    throw new Error("sendTextMessage failed on an unknown device");
+                }, (e) => {
+                    expect(e.name).toEqual("UnknownDeviceError");
+                }),
+                aliceTestClient.httpBackend.flushAllExpected(),
+            ]);
+        }).then(function() {
+            // mark the device as known, and resend.
+            aliceTestClient.client.setDeviceKnown('@bob:xyz', 'DEVICE_ID');
+
+            let inboundGroupSession;
+            aliceTestClient.httpBackend.when(
+                'PUT', '/sendToDevice/m.room.encrypted/',
+            ).respond(200, function(path, content) {
+                const m = content.messages['@bob:xyz'].DEVICE_ID;
+                const ct = m.ciphertext[testSenderKey];
+                const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
+
+                expect(decrypted.type).toEqual('m.room_key');
+                inboundGroupSession = new Olm.InboundGroupSession();
+                inboundGroupSession.create(decrypted.content.session_key);
+                return {};
+            });
+
+            aliceTestClient.httpBackend.when(
+                'PUT', '/send/',
+            ).respond(200, function(path, content) {
+                const ct = content.ciphertext;
+                const r = inboundGroupSession.decrypt(ct);
+                console.log('Decrypted received megolm message', r);
+
+                expect(r.message_index).toEqual(0);
+                const decrypted = JSON.parse(r.plaintext);
+                expect(decrypted.type).toEqual('m.room.message');
+                expect(decrypted.content.body).toEqual('test');
+
+                return {
+                    event_id: '$event_id',
+                };
+            });
+
+            const room = aliceTestClient.client.getRoom(ROOM_ID);
+            const pendingMsg = room.getPendingEvents()[0];
+
+            return Promise.all([
+                aliceTestClient.client.resendEvent(pendingMsg, room),
+
+                // the crypto stuff can take a while, so give the requests a whole second.
+                aliceTestClient.httpBackend.flushAllExpected({
+                    timeout: 1000,
+                }),
+            ]);
+        });
+    });
+
+    it("We shouldn't attempt to send to blocked devices", function() {
+        return aliceTestClient.start().then(() => {
+            // establish an olm session with alice
+            return createOlmSession(testOlmAccount, aliceTestClient);
+        }).then((p2pSession) => {
+            const syncResponse = getSyncResponse(['@bob:xyz']);
+
+            const olmEvent = encryptOlmEvent({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+            });
+
+            syncResponse.to_device = { events: [olmEvent] };
+            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            console.log('Forcing alice to download our device keys');
+
+            aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
+                200, getTestKeysQueryResponse('@bob:xyz'),
+            );
+
+            return Promise.all([
+                aliceTestClient.client.downloadKeys(['@bob:xyz']),
+                aliceTestClient.httpBackend.flush('/keys/query', 1),
+            ]);
+        }).then(function() {
+            console.log('Telling alice to block our device');
+            aliceTestClient.client.setDeviceBlocked('@bob:xyz', 'DEVICE_ID');
+
+            console.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 start a new megolm session when a device is blocked", function() {
+        let p2pSession;
+        let megolmSessionId;
+
+        return aliceTestClient.start().then(() => {
+            // establish an olm session with alice
+            return createOlmSession(testOlmAccount, aliceTestClient);
+        }).then((_p2pSession) => {
+            p2pSession = _p2pSession;
+
+            const syncResponse = getSyncResponse(['@bob:xyz']);
+
+            const olmEvent = encryptOlmEvent({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+            });
+
+            syncResponse.to_device = { events: [olmEvent] };
+            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            console.log("Fetching bob's devices and marking known");
+
+            aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
+                200, getTestKeysQueryResponse('@bob:xyz'),
+            );
+
+            return Promise.all([
+                aliceTestClient.client.downloadKeys(['@bob:xyz']),
+                aliceTestClient.httpBackend.flushAllExpected(),
+            ]).then((keys) => {
+                aliceTestClient.client.setDeviceKnown('@bob:xyz', 'DEVICE_ID');
+            });
+        }).then(function() {
+            console.log('Telling alice to send a megolm message');
+
+            aliceTestClient.httpBackend.when(
+                'PUT', '/sendToDevice/m.room.encrypted/',
+            ).respond(200, function(path, content) {
+                console.log('sendToDevice: ', content);
+                const m = content.messages['@bob:xyz'].DEVICE_ID;
+                const ct = m.ciphertext[testSenderKey];
+                expect(ct.type).toEqual(1); // normal message
+                const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
+                console.log('decrypted sendToDevice:', decrypted);
+                expect(decrypted.type).toEqual('m.room_key');
+                megolmSessionId = decrypted.content.session_id;
+                return {};
+            });
+
+            aliceTestClient.httpBackend.when(
+                'PUT', '/send/',
+            ).respond(200, function(path, content) {
+                console.log('/send:', content);
+                expect(content.session_id).toEqual(megolmSessionId);
+                return {
+                    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,
+                }),
+            ]);
+        }).then(function() {
+            console.log('Telling alice to block our device');
+            aliceTestClient.client.setDeviceBlocked('@bob:xyz', 'DEVICE_ID');
+
+            console.log('Telling alice to send another megolm message');
+            aliceTestClient.httpBackend.when(
+                'PUT', '/send/',
+            ).respond(200, function(path, content) {
+                console.log('/send:', content);
+                expect(content.session_id).toNotEqual(megolmSessionId);
+                return {
+                    event_id: '$event_id',
+                };
+            });
+
+            return Promise.all([
+                aliceTestClient.client.sendTextMessage(ROOM_ID, 'test2'),
+                aliceTestClient.httpBackend.flushAllExpected(),
+            ]);
+        });
+    });
+
+    // https://github.com/vector-im/riot-web/issues/2676
+    it("Alice should send to her other devices", function() {
+        // for this test, we make the testOlmAccount be another of Alice's devices.
+        // it ought to get included in messages Alice sends.
+
+        let p2pSession;
+        let inboundGroupSession;
+        let decrypted;
+
+        return aliceTestClient.start().then(function() {
+            // an encrypted room with just alice
+            const syncResponse = {
+                next_batch: 1,
+                rooms: {
+                    join: {},
+                },
+            };
+            syncResponse.rooms.join[ROOM_ID] = {
+                state: {
+                    events: [
+                        testUtils.mkEvent({
+                            type: 'm.room.encryption',
+                            skey: '',
+                            content: {
+                                algorithm: 'm.megolm.v1.aes-sha2',
+                            },
+                        }),
+                        testUtils.mkMembership({
+                            mship: 'join',
+                            sender: aliceTestClient.userId,
+                        }),
+                    ],
+                },
+            };
+            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+
+            // the completion of the first initialsync hould make Alice
+            // invalidate the device cache for all members in e2e rooms (ie,
+            // herself), and do a key query.
+            aliceTestClient.expectKeyQuery(
+                getTestKeysQueryResponse(aliceTestClient.userId),
+            );
+
+            return aliceTestClient.httpBackend.flushAllExpected();
+        }).then(function() {
+            // start out with the device unknown - the send should be rejected.
+            return aliceTestClient.client.sendTextMessage(ROOM_ID, 'test').then(() => {
+                throw new Error("sendTextMessage failed on an unknown device");
+            }, (e) => {
+                expect(e.name).toEqual("UnknownDeviceError");
+                expect(Object.keys(e.devices)).toEqual([aliceTestClient.userId]);
+                expect(Object.keys(e.devices[aliceTestClient.userId])).
+                    toEqual(['DEVICE_ID']);
+            });
+        }).then(function() {
+            // mark the device as known, and resend.
+            aliceTestClient.client.setDeviceKnown(aliceTestClient.userId, 'DEVICE_ID');
+            aliceTestClient.httpBackend.when('POST', '/keys/claim').respond(
+                200, function(path, content) {
+                expect(content.one_time_keys[aliceTestClient.userId].DEVICE_ID)
+                    .toEqual("signed_curve25519");
+                return getTestKeysClaimResponse(aliceTestClient.userId);
+            });
+
+            aliceTestClient.httpBackend.when(
+                'PUT', '/sendToDevice/m.room.encrypted/',
+            ).respond(200, function(path, content) {
+                console.log("sendToDevice: ", content);
+                const m = content.messages[aliceTestClient.userId].DEVICE_ID;
+                const ct = m.ciphertext[testSenderKey];
+                expect(ct.type).toEqual(0); // pre-key message
+
+                p2pSession = new Olm.Session();
+                p2pSession.create_inbound(testOlmAccount, ct.body);
+                const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
+
+                expect(decrypted.type).toEqual('m.room_key');
+                inboundGroupSession = new Olm.InboundGroupSession();
+                inboundGroupSession.create(decrypted.content.session_key);
+                return {};
+            });
+
+            aliceTestClient.httpBackend.when(
+                'PUT', '/send/',
+            ).respond(200, function(path, content) {
+                const ct = content.ciphertext;
+                const r = inboundGroupSession.decrypt(ct);
+                console.log('Decrypted received megolm message', r);
+                decrypted = JSON.parse(r.plaintext);
+
+                return {
+                    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,
+                }),
+            ]);
+        }).then(function() {
+            expect(decrypted.type).toEqual('m.room.message');
+            expect(decrypted.content.body).toEqual('test');
+        });
+    });
+
+
+    it('Alice should wait for device list to complete when sending a megolm message',
+    function() {
+        let downloadPromise;
+        let sendPromise;
+
+        return aliceTestClient.start().then(() => {
+            // establish an olm session with alice
+            return createOlmSession(testOlmAccount, aliceTestClient);
+        }).then((p2pSession) => {
+            const syncResponse = getSyncResponse(['@bob:xyz']);
+
+            const olmEvent = encryptOlmEvent({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+            });
+
+            syncResponse.to_device = { events: [olmEvent] };
+
+            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            // this will block
+            console.log('Forcing alice to download our device keys');
+            downloadPromise = aliceTestClient.client.downloadKeys(['@bob:xyz']);
+
+            // so will this.
+            sendPromise = aliceTestClient.client.sendTextMessage(ROOM_ID, 'test')
+            .then(() => {
+                throw new Error("sendTextMessage failed on an unknown device");
+            }, (e) => {
+                expect(e.name).toEqual("UnknownDeviceError");
+            });
+
+            aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
+                200, getTestKeysQueryResponse('@bob:xyz'),
+            );
+
+            return aliceTestClient.httpBackend.flushAllExpected();
+        }).then(function() {
+            return Promise.all([downloadPromise, sendPromise]);
+        });
+    });
+
+
+    it("Alice exports megolm keys and imports them to a new device", function() {
+        let messageEncrypted;
+
+        return aliceTestClient.start().then(() => {
+            // establish an olm session with alice
+            return createOlmSession(testOlmAccount, aliceTestClient);
+        }).then((p2pSession) => {
+            const groupSession = new Olm.OutboundGroupSession();
+            groupSession.create();
+
+            // make the room_key event
+            const roomKeyEncrypted = encryptGroupSessionKey({
+                senderKey: testSenderKey,
+                recipient: aliceTestClient,
+                p2pSession: p2pSession,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            // encrypt a message with the group session
+            messageEncrypted = encryptMegolmEvent({
+                senderKey: testSenderKey,
+                groupSession: groupSession,
+                room_id: ROOM_ID,
+            });
+
+            // Alice gets both the events in a single sync
+            const syncResponse = {
+                next_batch: 1,
+                to_device: {
+                    events: [roomKeyEncrypted],
+                },
+                rooms: {
+                    join: {},
+                },
+            };
+            syncResponse.rooms.join[ROOM_ID] = {
+                timeline: {
+                    events: [messageEncrypted],
+                },
+            };
+
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            const room = aliceTestClient.client.getRoom(ROOM_ID);
+            const event = room.getLiveTimeline().getEvents()[0];
+            expect(event.getContent().body).toEqual('42');
+
+            return aliceTestClient.client.exportRoomKeys();
+        }).then(function(exported) {
+            // start a new client
+            aliceTestClient.stop();
+
+            aliceTestClient = new TestClient(
+                "@alice:localhost", "device2", "access_token2",
+            );
+            return aliceTestClient.client.initCrypto().then(() => {
+                aliceTestClient.client.importRoomKeys(exported);
+                return aliceTestClient.start();
+            });
+        }).then(function() {
+            const syncResponse = {
+                next_batch: 1,
+                rooms: {
+                    join: {},
+                },
+            };
+            syncResponse.rooms.join[ROOM_ID] = {
+                timeline: {
+                    events: [messageEncrypted],
+                },
+            };
+
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+            return aliceTestClient.flushSync();
+        }).then(function() {
+            const room = aliceTestClient.client.getRoom(ROOM_ID);
+            const event = room.getLiveTimeline().getEvents()[0];
+            expect(event.getContent().body).toEqual('42');
+        });
+    });
+});
@@ -1,5 +1,5 @@
 /*
-Copyright 2021 The Matrix.org Foundation C.I.C.
+Copyright 2017 Vector creations Ltd

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,12 +14,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-export interface ISignatures {
-    [entity: string]: {
-        [keyId: string]: string;
-    };
-}
+// try to load the olm library.

-export interface ISigned {
-    signatures?: ISignatures;
+try {
+    global.Olm = require('olm');
+    console.log('loaded libolm');
+} catch (e) {
+    console.warn("unable to run crypto tests: libolm not available");
 }
@@ -1,27 +0,0 @@
-/*
-Copyright 2017 Vector creations 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 { logger } from "../src/logger";
-
-// try to load the olm library.
-try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    global.Olm = require("@matrix-org/olm");
-    logger.log("loaded libolm");
-} catch (e) {
-    logger.warn("unable to run crypto tests: libolm not available", e);
-}
@@ -1,25 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import DOMException from "domexception";
-
-global.DOMException = DOMException as typeof global.DOMException;
-
-jest.mock("../src/http-api/utils", () => ({
-    ...jest.requireActual("../src/http-api/utils"),
-    // We mock timeoutSignal otherwise it causes tests to leave timers running
-    timeoutSignal: () => new AbortController().signal,
-}));
@@ -1,100 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/* eslint-disable no-console */
-
-class JestSlowTestReporter {
-    constructor(globalConfig, options) {
-        this._globalConfig = globalConfig;
-        this._options = options;
-        this._slowTests = [];
-        this._slowTestSuites = [];
-    }
-
-    onRunComplete() {
-        const displayResult = (result, isTestSuite) => {
-            if (!isTestSuite) console.log();
-
-            result.sort((a, b) => b.duration - a.duration);
-            const rootPathRegex = new RegExp(`^${process.cwd()}`);
-            const slowestTests = result.slice(0, this._options.numTests || 10);
-            const slowTestTime = this._slowTestTime(slowestTests);
-            const allTestTime = this._allTestTime(result);
-            const percentTime = (slowTestTime / allTestTime) * 100;
-
-            if (isTestSuite) {
-                console.log(
-                    `Top ${slowestTests.length} slowest test suites (${slowTestTime / 1000} seconds,` +
-                        ` ${percentTime.toFixed(1)}% of total time):`,
-                );
-            } else {
-                console.log(
-                    `Top ${slowestTests.length} slowest tests (${slowTestTime / 1000} seconds,` +
-                        ` ${percentTime.toFixed(1)}% of total time):`,
-                );
-            }
-
-            for (let i = 0; i < slowestTests.length; i++) {
-                const duration = slowestTests[i].duration;
-                const filePath = slowestTests[i].filePath.replace(rootPathRegex, ".");
-
-                if (isTestSuite) {
-                    console.log(`  ${duration / 1000} seconds ${filePath}`);
-                } else {
-                    const fullName = slowestTests[i].fullName;
-                    console.log(`  ${fullName}`);
-                    console.log(`    ${duration / 1000} seconds ${filePath}`);
-                }
-            }
-            console.log();
-        };
-
-        displayResult(this._slowTests);
-        displayResult(this._slowTestSuites, true);
-    }
-
-    onTestResult(test, testResult) {
-        this._slowTestSuites.push({
-            duration: testResult.perfStats.runtime,
-            filePath: testResult.testFilePath,
-        });
-        for (let i = 0; i < testResult.testResults.length; i++) {
-            this._slowTests.push({
-                duration: testResult.testResults[i].duration,
-                fullName: testResult.testResults[i].fullName,
-                filePath: testResult.testFilePath,
-            });
-        }
-    }
-
-    _slowTestTime(slowestTests) {
-        let slowTestTime = 0;
-        for (let i = 0; i < slowestTests.length; i++) {
-            slowTestTime += slowestTests[i].duration;
-        }
-        return slowTestTime;
-    }
-
-    _allTestTime(result) {
-        let allTestTime = 0;
-        for (let i = 0; i < result.length; i++) {
-            allTestTime += result[i].duration;
-        }
-        return allTestTime;
-    }
-}
-
-module.exports = JestSlowTestReporter;
@@ -0,0 +1,243 @@
+"use strict";
+import expect from 'expect';
+import Promise from 'bluebird';
+
+// load olm before the sdk if possible
+import './olm-loader';
+
+import sdk from '..';
+const MatrixEvent = sdk.MatrixEvent;
+
+/**
+ * Return a promise that is resolved when the client next emits a
+ * SYNCING event.
+ * @param {Object} client The client
+ * @param {Number=} count Number of syncs to wait for (default 1)
+ * @return {Promise} Resolves once the client has emitted a SYNCING event
+ */
+module.exports.syncPromise = function(client, count) {
+    if (count === undefined) {
+        count = 1;
+    }
+    if (count <= 0) {
+        return Promise.resolve();
+    }
+
+    const p = new Promise((resolve, reject) => {
+        const cb = (state) => {
+            console.log(`${Date.now()} syncPromise(${count}): ${state}`);
+            if (state == 'SYNCING') {
+                resolve();
+            } else {
+                client.once('sync', cb);
+            }
+        };
+        client.once('sync', cb);
+    });
+
+    return p.then(() => {
+        return module.exports.syncPromise(client, count-1);
+    });
+};
+
+/**
+ * Perform common actions before each test case, e.g. printing the test case
+ * name to stdout.
+ * @param {Mocha.Context} context  The test context
+ */
+module.exports.beforeEach = function(context) {
+    const desc = context.currentTest.fullTitle();
+
+    console.log(desc);
+    console.log(new Array(1 + desc.length).join("="));
+};
+
+/**
+ * Create a spy for an object and automatically spy its methods.
+ * @param {*} constr The class constructor (used with 'new')
+ * @param {string} name The name of the class
+ * @return {Object} An instantiated object with spied methods/properties.
+ */
+module.exports.mock = function(constr, name) {
+    // Based on
+    // http://eclipsesource.com/blogs/2014/03/27/mocks-in-jasmine-tests/
+    const HelperConstr = new Function(); // jshint ignore:line
+    HelperConstr.prototype = constr.prototype;
+    const result = new HelperConstr();
+    result.toString = function() {
+        return "mock" + (name ? " of " + name : "");
+    };
+    for (const key in constr.prototype) { // eslint-disable-line guard-for-in
+        try {
+            if (constr.prototype[key] instanceof Function) {
+                result[key] = expect.createSpy();
+            }
+        } catch (ex) {
+            // Direct access to some non-function fields of DOM prototypes may
+            // cause exceptions.
+            // Overwriting will not work either in that case.
+        }
+    }
+    return result;
+};
+
+/**
+ * Create an Event.
+ * @param {Object} opts Values for the event.
+ * @param {string} opts.type The event.type
+ * @param {string} opts.room The event.room_id
+ * @param {string} opts.sender The event.sender
+ * @param {string} opts.skey Optional. The state key (auto inserts empty string)
+ * @param {Object} opts.content The event.content
+ * @param {boolean} opts.event True to make a MatrixEvent.
+ * @return {Object} a JSON object representing this event.
+ */
+module.exports.mkEvent = function(opts) {
+    if (!opts.type || !opts.content) {
+        throw new Error("Missing .type or .content =>" + JSON.stringify(opts));
+    }
+    const event = {
+        type: opts.type,
+        room_id: opts.room,
+        sender: opts.sender || opts.user, // opts.user for backwards-compat
+        content: opts.content,
+        event_id: "$" + Math.random() + "-" + Math.random(),
+    };
+    if (opts.skey !== undefined) {
+        event.state_key = opts.skey;
+    } else if (["m.room.name", "m.room.topic", "m.room.create", "m.room.join_rules",
+         "m.room.power_levels", "m.room.topic",
+         "com.example.state"].indexOf(opts.type) !== -1) {
+        event.state_key = "";
+    }
+    return opts.event ? new MatrixEvent(event) : event;
+};
+
+/**
+ * Create an m.presence event.
+ * @param {Object} opts Values for the presence.
+ * @return {Object|MatrixEvent} The event
+ */
+module.exports.mkPresence = function(opts) {
+    if (!opts.user) {
+        throw new Error("Missing user");
+    }
+    const event = {
+        event_id: "$" + Math.random() + "-" + Math.random(),
+        type: "m.presence",
+        sender: opts.sender || opts.user, // opts.user for backwards-compat
+        content: {
+            avatar_url: opts.url,
+            displayname: opts.name,
+            last_active_ago: opts.ago,
+            presence: opts.presence || "offline",
+        },
+    };
+    return opts.event ? new MatrixEvent(event) : event;
+};
+
+/**
+ * Create an m.room.member event.
+ * @param {Object} opts Values for the membership.
+ * @param {string} opts.room The room ID for the event.
+ * @param {string} opts.mship The content.membership for the event.
+ * @param {string} opts.sender The sender user ID for the event.
+ * @param {string} opts.skey The target user ID for the event if applicable
+ * e.g. for invites/bans.
+ * @param {string} opts.name The content.displayname for the event.
+ * @param {string} opts.url The content.avatar_url for the event.
+ * @param {boolean} opts.event True to make a MatrixEvent.
+ * @return {Object|MatrixEvent} The event
+ */
+module.exports.mkMembership = function(opts) {
+    opts.type = "m.room.member";
+    if (!opts.skey) {
+        opts.skey = opts.sender || opts.user;
+    }
+    if (!opts.mship) {
+        throw new Error("Missing .mship => " + JSON.stringify(opts));
+    }
+    opts.content = {
+        membership: opts.mship,
+    };
+    if (opts.name) {
+        opts.content.displayname = opts.name;
+    }
+    if (opts.url) {
+        opts.content.avatar_url = opts.url;
+    }
+    return module.exports.mkEvent(opts);
+};
+
+/**
+ * Create an m.room.message event.
+ * @param {Object} opts Values for the message
+ * @param {string} opts.room The room ID for the event.
+ * @param {string} opts.user The user ID for the event.
+ * @param {string} opts.msg Optional. The content.body for the event.
+ * @param {boolean} opts.event True to make a MatrixEvent.
+ * @return {Object|MatrixEvent} The event
+ */
+module.exports.mkMessage = function(opts) {
+    opts.type = "m.room.message";
+    if (!opts.msg) {
+        opts.msg = "Random->" + Math.random();
+    }
+    if (!opts.room || !opts.user) {
+        throw new Error("Missing .room or .user from %s", opts);
+    }
+    opts.content = {
+        msgtype: "m.text",
+        body: opts.msg,
+    };
+    return module.exports.mkEvent(opts);
+};
+
+
+/**
+ * A mock implementation of webstorage
+ *
+ * @constructor
+ */
+module.exports.MockStorageApi = function() {
+    this.data = {};
+};
+module.exports.MockStorageApi.prototype = {
+    get length() {
+        return Object.keys(this.data).length;
+    },
+    key: function(i) {
+        return Object.keys(this.data)[i];
+    },
+    setItem: function(k, v) {
+        this.data[k] = v;
+    },
+    getItem: function(k) {
+        return this.data[k] || null;
+    },
+    removeItem: function(k) {
+        delete this.data[k];
+    },
+};
+
+
+/**
+ * If an event is being decrypted, wait for it to finish being decrypted.
+ *
+ * @param {MatrixEvent} event
+ * @returns {Promise} promise which resolves (to `event`) when the event has been decrypted
+ */
+module.exports.awaitDecryption = function(event) {
+    if (!event.isBeingDecrypted()) {
+        return Promise.resolve(event);
+    }
+
+    console.log(`${Date.now()} event ${event.getId()} is being decrypted; waiting`);
+
+    return new Promise((resolve, reject) => {
+        event.once('Event.decrypted', (ev) => {
+            console.log(`${Date.now()} event ${event.getId()} now decrypted`);
+            resolve(ev);
+        });
+    });
+};
@@ -1,164 +0,0 @@
-/*
-Copyright 2023 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import debugFunc from "debug";
-import { Debugger } from "debug";
-import fetchMock from "fetch-mock-jest";
-
-import type { IDeviceKeys, IOneTimeKey } from "../../src/@types/crypto";
-
-/** Interface implemented by classes that intercept `/keys/upload` requests from test clients to catch the uploaded keys
- *
- * Common interface implemented by {@link TestClient} and {@link E2EKeyReceiver}
- */
-export interface IE2EKeyReceiver {
-    /**
-     * get the uploaded ed25519 device key
-     *
-     * @returns base64 device key
-     */
-    getSigningKey(): string;
-
-    /**
-     * get the uploaded curve25519 device key
-     *
-     * @returns base64 device key
-     */
-    getDeviceKey(): string;
-
-    /**
-     * Wait for one-time-keys to be uploaded, then return them.
-     *
-     * @returns Promise for the one-time keys
-     */
-    awaitOneTimeKeyUpload(): Promise<Record<string, IOneTimeKey>>;
-}
-
-/** E2EKeyReceiver: An object which intercepts `/keys/uploads` fetches via fetch-mock.
- *
- * It stashes the uploaded keys for use elsewhere in the tests.
- */
-export class E2EKeyReceiver implements IE2EKeyReceiver {
-    private readonly debug: Debugger;
-
-    private deviceKeys: IDeviceKeys | null = null;
-    private oneTimeKeys: Record<string, IOneTimeKey> = {};
-    private readonly oneTimeKeysPromise: Promise<void>;
-
-    /**
-     * Construct a new E2EKeyReceiver.
-     *
-     * It will immediately register an intercept of `/keys/uploads` requests for the given homeserverUrl.
-     * Only /upload requests made to this server will be intercepted: this allows a single test to use more than one
-     * client and have the keys collected separately.
-     *
-     * @param homeserverUrl - the Homeserver Url of the client under test.
-     */
-    public constructor(homeserverUrl: string) {
-        this.debug = debugFunc(`e2e-key-receiver:[${homeserverUrl}]`);
-
-        // set up a listener for /keys/upload.
-        this.oneTimeKeysPromise = new Promise((resolveOneTimeKeys) => {
-            const listener = (url: string, options: RequestInit) =>
-                this.onKeyUploadRequest(resolveOneTimeKeys, options);
-
-            fetchMock.post(new URL("/_matrix/client/v3/keys/upload", homeserverUrl).toString(), listener);
-        });
-    }
-
-    private async onKeyUploadRequest(onOnTimeKeysUploaded: () => void, options: RequestInit): Promise<object> {
-        const content = JSON.parse(options.body as string);
-
-        // device keys may only be uploaded once
-        if (content.device_keys && Object.keys(content.device_keys).length > 0) {
-            if (this.deviceKeys) {
-                throw new Error("Application attempted to upload E2E device keys multiple times");
-            }
-            this.debug(`received device keys`);
-            this.deviceKeys = content.device_keys;
-        }
-
-        if (content.one_time_keys && Object.keys(content.one_time_keys).length > 0) {
-            // this is a one-time-key upload
-
-            // if we already have a batch of one-time keys, then slow-roll the response,
-            // otherwise the client ends up tight-looping one-time-key-uploads and filling the logs with junk.
-            if (Object.keys(this.oneTimeKeys).length > 0) {
-                this.debug(`received second batch of one-time keys: blocking response`);
-                await new Promise(() => {});
-            }
-
-            this.debug(`received ${Object.keys(content.one_time_keys).length} one-time keys`);
-            Object.assign(this.oneTimeKeys, content.one_time_keys);
-            onOnTimeKeysUploaded();
-        }
-
-        return {
-            one_time_key_counts: {
-                signed_curve25519: Object.keys(this.oneTimeKeys).length,
-            },
-        };
-    }
-
-    /** Get the uploaded Ed25519 key
-     *
-     * If device keys have not yet been uploaded, throws an error
-     */
-    public getSigningKey(): string {
-        if (!this.deviceKeys) {
-            throw new Error("Device keys not yet uploaded");
-        }
-        const keyIds = Object.keys(this.deviceKeys.keys).filter((v) => v.startsWith("ed25519:"));
-        if (keyIds.length != 1) {
-            throw new Error(`Expected exactly 1 ed25519 key uploaded, got ${keyIds}`);
-        }
-        return this.deviceKeys.keys[keyIds[0]];
-    }
-
-    /** Get the uploaded Curve25519 key
-     *
-     * If device keys have not yet been uploaded, throws an error
-     */
-    public getDeviceKey(): string {
-        if (!this.deviceKeys) {
-            throw new Error("Device keys not yet uploaded");
-        }
-        const keyIds = Object.keys(this.deviceKeys.keys).filter((v) => v.startsWith("curve25519:"));
-        if (keyIds.length != 1) {
-            throw new Error(`Expected exactly 1 curve25519 key uploaded, got ${keyIds}`);
-        }
-        return this.deviceKeys.keys[keyIds[0]];
-    }
-
-    /**
-     * If the device keys have already been uploaded, return them. Else return null.
-     */
-    public getUploadedDeviceKeys(): IDeviceKeys | null {
-        return this.deviceKeys;
-    }
-
-    /**
-     * 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 async awaitOneTimeKeyUpload(): Promise<Record<string, IOneTimeKey>> {
-        await this.oneTimeKeysPromise;
-        return this.oneTimeKeys;
-    }
-}
@@ -1,119 +0,0 @@
-/*
-Copyright 2023 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import fetchMock from "fetch-mock-jest";
-
-import { MapWithDefault } from "../../src/utils";
-import { IDownloadKeyResult } from "../../src";
-import { IDeviceKeys } from "../../src/@types/crypto";
-import { E2EKeyReceiver } from "./E2EKeyReceiver";
-
-/**
- * An object which intercepts `/keys/query` fetches via fetch-mock.
- */
-export class E2EKeyResponder {
-    private deviceKeysByUserByDevice = new MapWithDefault<string, Map<string, any>>(() => new Map());
-    private e2eKeyReceiversByUser = new Map<string, E2EKeyReceiver>();
-    private masterKeysByUser: Record<string, any> = {};
-    private selfSigningKeysByUser: Record<string, any> = {};
-    private userSigningKeysByUser: Record<string, any> = {};
-
-    /**
-     * Construct a new E2EKeyResponder.
-     *
-     * It will immediately register an intercept of `/keys/query` requests for the given homeserverUrl.
-     * Only /query requests made to this server will be intercepted: this allows a single test to use more than one
-     * client and have the keys collected separately.
-     *
-     * @param homeserverUrl - the Homeserver Url of the client under test.
-     */
-    public constructor(homeserverUrl: string) {
-        // set up a listener for /keys/query.
-        const listener = (url: string, options: RequestInit) => this.onKeyQueryRequest(options);
-        fetchMock.post(new URL("/_matrix/client/v3/keys/query", homeserverUrl).toString(), listener);
-    }
-
-    private onKeyQueryRequest(options: RequestInit) {
-        const content = JSON.parse(options.body as string);
-        const usersToReturn = Object.keys(content["device_keys"]);
-        const response = {
-            device_keys: {} as { [userId: string]: any },
-            master_keys: {} as { [userId: string]: any },
-            self_signing_keys: {} as { [userId: string]: any },
-            user_signing_keys: {} as { [userId: string]: any },
-            failures: {} as { [serverName: string]: any },
-        };
-        for (const user of usersToReturn) {
-            const userKeys = this.deviceKeysByUserByDevice.get(user);
-            if (userKeys !== undefined) {
-                response.device_keys[user] = Object.fromEntries(userKeys.entries());
-            }
-
-            const e2eKeyReceiver = this.e2eKeyReceiversByUser.get(user);
-            if (e2eKeyReceiver !== undefined) {
-                const deviceKeys = e2eKeyReceiver.getUploadedDeviceKeys();
-                if (deviceKeys !== null) {
-                    response.device_keys[user] ??= {};
-                    response.device_keys[user][deviceKeys.device_id] = deviceKeys;
-                }
-            }
-
-            if (this.masterKeysByUser.hasOwnProperty(user)) {
-                response.master_keys[user] = this.masterKeysByUser[user];
-            }
-            if (this.selfSigningKeysByUser.hasOwnProperty(user)) {
-                response.self_signing_keys[user] = this.selfSigningKeysByUser[user];
-            }
-            if (this.userSigningKeysByUser.hasOwnProperty(user)) {
-                response.user_signing_keys[user] = this.userSigningKeysByUser[user];
-            }
-        }
-        return response;
-    }
-
-    /**
-     * Add a set of device keys for return by a future `/keys/query`, as if they had been `/upload`ed
-     *
-     * @param keys - device keys for this device.
-     */
-    public addDeviceKeys(keys: IDeviceKeys) {
-        this.deviceKeysByUserByDevice.getOrCreate(keys.user_id).set(keys.device_id, keys);
-    }
-
-    /** Add a set of cross-signing keys for return by a future `/keys/query`, as if they had been `/keys/device_signing/upload`ed
-     *
-     * @param data cross-signing data
-     */
-    public addCrossSigningData(
-        data: Pick<IDownloadKeyResult, "master_keys" | "self_signing_keys" | "user_signing_keys">,
-    ) {
-        Object.assign(this.masterKeysByUser, data.master_keys);
-        Object.assign(this.selfSigningKeysByUser, data.self_signing_keys);
-        Object.assign(this.userSigningKeysByUser, data.user_signing_keys);
-    }
-
-    /**
-     * Add an E2EKeyReceiver to poll for uploaded keys
-     *
-     * Any keys which have been uploaded to the given `E2EKeyReceiver` at the time of the `/keys/query` request will
-     * be added to the response.
-     *
-     * @param e2eKeyReceiver
-     */
-    public addKeyReceiver(userId: string, e2eKeyReceiver: E2EKeyReceiver) {
-        this.e2eKeyReceiversByUser.set(userId, e2eKeyReceiver);
-    }
-}
@@ -1,131 +0,0 @@
-/*
-Copyright 2023 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import debugFunc from "debug";
-import { Debugger } from "debug";
-import fetchMock from "fetch-mock-jest";
-import { MockResponse } from "fetch-mock";
-
-/** Interface implemented by classes that intercept `/sync` requests from test clients
- *
- * Common interface implemented by {@link TestClient} and {@link SyncResponder}
- */
-export interface ISyncResponder {
-    /** Next time we see a sync request (or immediately, if there is one waiting), send the given response
-     *
-     * @param response - response to /sync request
-     */
-    sendOrQueueSyncResponse(response: object): void;
-}
-
-enum SyncResponderState {
-    IDLE,
-    WAITING_FOR_REQUEST,
-    WAITING_FOR_RESPONSE,
-}
-
-/** SyncResponder: An object which intercepts `/sync` fetches via fetch-mock.
- *
- * Two modes are possible:
- *  * A response can be queued up; the next call to `/sync` will return it.
- *  * If a call to `/sync` arrives before a response is queued, it will block until a call to {@link #sendOrQueueSyncResponse}.
- */
-export class SyncResponder implements ISyncResponder {
-    private readonly debug: Debugger;
-    private state: SyncResponderState = SyncResponderState.IDLE;
-
-    /*
-     * properties that are only valid in WAITING_FOR_REQUEST
-     */
-
-    /** the response to be sent when the request is made */
-    private pendingResponse: object | null = null;
-
-    /*
-     * properties that are only valid in WAITING_FOR_RESPONSE
-     */
-
-    /** a callback to be called with a response once one is registered.
-     *
-     * It will release the /sync request and update the state.
-     */
-    private onResponseReceived: ((response: object) => void) | null = null;
-
-    /**
-     * Construct a new SyncResponder.
-     *
-     * It will immediately register an intercept of `/sync` requests for the given homeserverUrl.
-     * Only /sync requests made to this server will be intercepted: this allows a single test to use more than one
-     * client and have overlapping /sync requests.
-     *
-     * @param homeserverUrl - the Homeserver Url of the client under test.
-     */
-    public constructor(homeserverUrl: string) {
-        this.debug = debugFunc(`sync-responder:[${homeserverUrl}]`);
-        fetchMock.get("begin:" + new URL("/_matrix/client/v3/sync?", homeserverUrl).toString(), (_url, _options) =>
-            this.onSyncRequest(),
-        );
-    }
-
-    private async onSyncRequest(): Promise<MockResponse> {
-        switch (this.state) {
-            case SyncResponderState.IDLE: {
-                this.debug("Got /sync request: waiting for response to be ready");
-                const res = await new Promise<object>((resolve) => {
-                    this.onResponseReceived = resolve;
-                    this.state = SyncResponderState.WAITING_FOR_RESPONSE;
-                });
-                this.debug("Responding to /sync");
-                this.state = SyncResponderState.IDLE;
-                this.onResponseReceived = null;
-                return res;
-            }
-
-            case SyncResponderState.WAITING_FOR_REQUEST: {
-                this.debug("Got /sync request: responding immediately with queued response");
-                const res = this.pendingResponse!;
-                this.state = SyncResponderState.IDLE;
-                this.pendingResponse = null;
-                return res;
-            }
-
-            default:
-                // we must already be in WAITING_FOR_RESPONSE, ie we already have a /sync request in progress
-                throw new Error(`Got unexpected /sync request in state ${this.state}`);
-        }
-    }
-
-    /** Next time we see a sync request (or immediately, if there is one waiting), send the given response
-     *
-     * @param response - response to /sync request
-     */
-    public sendOrQueueSyncResponse(response: object): void {
-        switch (this.state) {
-            case SyncResponderState.IDLE:
-                this.pendingResponse = response;
-                this.state = SyncResponderState.WAITING_FOR_REQUEST;
-                break;
-
-            case SyncResponderState.WAITING_FOR_RESPONSE:
-                this.onResponseReceived!(response);
-                break;
-
-            default:
-                // we already have a response queued
-                throw new Error(`Cannot queue more than one /sync response`);
-        }
-    }
-}
@@ -1,116 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import { MatrixEvent } from "../../src";
-import { M_BEACON, M_BEACON_INFO } from "../../src/@types/beacon";
-import { LocationAssetType } from "../../src/@types/location";
-import { makeBeaconContent, makeBeaconInfoContent } from "../../src/content-helpers";
-
-type InfoContentProps = {
-    timeout: number;
-    isLive?: boolean;
-    assetType?: LocationAssetType;
-    description?: string;
-    timestamp?: number;
-};
-const DEFAULT_INFO_CONTENT_PROPS: InfoContentProps = {
-    timeout: 3600000,
-};
-
-/**
- * Create an m.beacon_info event
- * all required properties are mocked
- * override with contentProps
- */
-export const makeBeaconInfoEvent = (
-    sender: string,
-    roomId: string,
-    contentProps: Partial<InfoContentProps> = {},
-    eventId?: string,
-): MatrixEvent => {
-    const { timeout, isLive, description, assetType, timestamp } = {
-        ...DEFAULT_INFO_CONTENT_PROPS,
-        ...contentProps,
-    };
-    const event = new MatrixEvent({
-        type: M_BEACON_INFO.name,
-        room_id: roomId,
-        state_key: sender,
-        content: makeBeaconInfoContent(timeout, isLive, description, assetType, timestamp),
-    });
-
-    event.event.origin_server_ts = timestamp || Date.now();
-
-    // live beacons use the beacon_info event id
-    // set or default this
-    event.replaceLocalEventId(eventId || `$${Math.random()}-${Math.random()}`);
-
-    return event;
-};
-
-type ContentProps = {
-    uri: string;
-    timestamp: number;
-    beaconInfoId: string;
-    description?: string;
-};
-const DEFAULT_CONTENT_PROPS: ContentProps = {
-    uri: "geo:-36.24484561954707,175.46884959563613;u=10",
-    timestamp: 123,
-    beaconInfoId: "$123",
-};
-
-/**
- * Create an m.beacon event
- * all required properties are mocked
- * override with contentProps
- */
-export const makeBeaconEvent = (sender: string, contentProps: Partial<ContentProps> = {}): MatrixEvent => {
-    const { uri, timestamp, beaconInfoId, description } = {
-        ...DEFAULT_CONTENT_PROPS,
-        ...contentProps,
-    };
-
-    return new MatrixEvent({
-        type: M_BEACON.name,
-        sender,
-        content: makeBeaconContent(uri, timestamp, beaconInfoId, description),
-    });
-};
-
-/**
- * Create a mock geolocation position
- * defaults all required properties
- */
-export const makeGeolocationPosition = ({
-    timestamp,
-    coords,
-}: {
-    timestamp?: number;
-    coords: Partial<GeolocationCoordinates>;
-}): GeolocationPosition => ({
-    timestamp: timestamp ?? 1647256791840,
-    coords: {
-        accuracy: 1,
-        latitude: 54.001927,
-        longitude: -8.253491,
-        altitude: null,
-        altitudeAccuracy: null,
-        heading: null,
-        speed: null,
-        ...coords,
-    },
-});
@@ -1,93 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import { MethodLikeKeys, mocked, MockedObject } from "jest-mock";
-
-import { ClientEventHandlerMap, EmittedEvents, MatrixClient } from "../../src/client";
-import { TypedEventEmitter } from "../../src/models/typed-event-emitter";
-import { User } from "../../src/models/user";
-
-/**
- * Mock client with real event emitter
- * useful for testing code that listens
- * to MatrixClient events
- */
-export class MockClientWithEventEmitter extends TypedEventEmitter<EmittedEvents, ClientEventHandlerMap> {
-    constructor(mockProperties: Partial<Record<MethodLikeKeys<MatrixClient>, unknown>> = {}) {
-        super();
-        Object.assign(this, mockProperties);
-    }
-}
-
-/**
- * - make a mock client
- * - cast the type to mocked(MatrixClient)
- * - spy on MatrixClientPeg.get to return the mock
- * eg
- * ```
- * const mockClient = getMockClientWithEventEmitter({
-        getUserId: jest.fn().mockReturnValue(aliceId),
-    });
- * ```
- */
-export const getMockClientWithEventEmitter = (
-    mockProperties: Partial<Record<MethodLikeKeys<MatrixClient>, unknown>>,
-): MockedObject<MatrixClient> => {
-    const mock = mocked(new MockClientWithEventEmitter(mockProperties) as unknown as MatrixClient);
-    return mock;
-};
-
-/**
- * Returns basic mocked client methods related to the current user
- * ```
- * const mockClient = getMockClientWithEventEmitter({
-        ...mockClientMethodsUser('@mytestuser:domain'),
-    });
- * ```
- */
-export const mockClientMethodsUser = (userId = "@alice:domain") => ({
-    getUserId: jest.fn().mockReturnValue(userId),
-    getSafeUserId: jest.fn().mockReturnValue(userId),
-    getUser: jest.fn().mockReturnValue(new User(userId)),
-    isGuest: jest.fn().mockReturnValue(false),
-    mxcUrlToHttp: jest.fn().mockReturnValue("mock-mxcUrlToHttp"),
-    credentials: { userId },
-    getThreePids: jest.fn().mockResolvedValue({ threepids: [] }),
-    getAccessToken: jest.fn(),
-});
-
-/**
- * Returns basic mocked client methods related to rendering events
- * ```
- * const mockClient = getMockClientWithEventEmitter({
-        ...mockClientMethodsUser('@mytestuser:domain'),
-    });
- * ```
- */
-export const mockClientMethodsEvents = () => ({
-    decryptEventIfNeeded: jest.fn(),
-    getPushActionsForEvent: jest.fn(),
-});
-
-/**
- * Returns basic mocked client methods related to server support
- */
-export const mockClientMethodsServer = (): Partial<Record<MethodLikeKeys<MatrixClient>, unknown>> => ({
-    getIdentityServerUrl: jest.fn(),
-    getHomeserverUrl: jest.fn(),
-    getCapabilities: jest.fn().mockReturnValue({}),
-    doesServerSupportUnstableFeature: jest.fn().mockResolvedValue(false),
-});
@@ -1,28 +0,0 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/**
- * Filter emitter.emit mock calls to find relevant events
- * eg:
- * ```
- * const emitSpy = jest.spyOn(state, 'emit');
- * << actions >>
- * const beaconLivenessEmits = emitCallsByEventType(BeaconEvent.New, emitSpy);
- * expect(beaconLivenessEmits.length).toBe(1);
- * ```
- */
-export const filterEmitCallsByEventType = (eventType: string, spy: jest.SpyInstance<any, any[]>) =>
-    spy.mock.calls.filter((args) => args[0] === eventType);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
David Baker	d764abc1d1	v0.9.2-cryptowraning.1	2018-03-26 14:11:29 +01:00
David Baker	ee0f8abe71	Prepare changelog for v0.9.2-cryptowraning.1	2018-03-26 14:11:29 +01:00
David Baker	b45e231968	Merge pull request #631 from matrix-org/dbkr/cryptowarning Disable crypto if indexeddb version too new	2018-03-26 14:04:42 +01:00
David Baker	c37db5ab9e	Remove added whitespace	2018-03-26 13:57:37 +01:00
David Baker	77abc45489	Disable crypto if indexeddb version too new	2018-03-23 17:29:35 +00:00
				`@@ -1 +0,0 @@`
				`module.exports = require("eslint-plugin-matrix-org/.prettierrc.js");`