v0.14.3

Prepare changelog for v0.14.3
v0.14.3-rc.1
2019-01-22 10:41:09 +00:00 · 2019-01-22 10:41:08 +00:00 · 2019-01-17 10:44:15 +00:00 · 2019-01-17 10:44:14 +00:00
356 changed files with 47528 additions and 104830 deletions
@@ -1,19 +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 = 2
@@ -1,89 +1,76 @@
 module.exports = {
-    plugins: [
-        "matrix-org",
-        "import",
-    ],
-    extends: [
-        "plugin:matrix-org/babel",
-        "plugin:import/typescript",
-    ],
+    parserOptions: {
+        ecmaVersion: 2017,
+        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"],
+        // 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",
+        }],
+
+        // loosen jsdoc requirements a little
+        "require-jsdoc": ["error", {
+            require: {
+                FunctionDeclaration: false,
+            }
+        }],
+        "valid-jsdoc": ["error", {
+            requireParamDescription: false,
+            requireReturn: false,
+            requireReturnDescription: false,
+        }],
+
+        // rules we do not want from eslint-recommended
+        "no-console": ["off"],
+        "no-constant-condition": ["off"],
+        "no-empty": ["error", { "allowEmptyCatch": true }],
+
+        // rules we do not want from the google styleguide
+        "object-curly-spacing": ["off"],
+        "spaced-comment": ["off"],
+
+        // in principle we prefer single quotes, but life is too short
+        quotes: ["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"],
        "no-multi-spaces": ["error", { "ignoreEOLComments": true }],
        "space-before-function-paren": ["error", {
            "anonymous": "never",
            "named": "never",
            "asyncArrow": "always",
        }],
-        "arrow-parens": "off",
-        "prefer-promise-reject-errors": "off",
-        "quotes": "off",
-        "indent": "off",
-        "no-constant-condition": "off",
-        "no-async-promise-executor": "off",
-        // We use a `logger` intermediary module
-        "no-console": "error",
-
-        // restrict EventEmitters to force callers to use TypedEventEmitter
-        "no-restricted-imports": ["error", {
-            name: "events",
-            message: "Please use TypedEventEmitter instead"
-        }],
-
-        "import/no-restricted-paths": ["error", {
-            "zones": [{
-                "target": "./src/",
-                "from": "./src/index.ts",
-                "message": "The package index is dynamic between src and lib depending on " +
-                    "whether release or development, target the specific module or matrix.ts instead",
-            }],
-        }],
-    },
-    overrides: [{
-        files: [
-            "**/*.ts",
-        ],
-        extends: [
-            "plugin:matrix-org/typescript",
-        ],
-        rules: {
-            // TypeScript has its own version of this
-            "@babel/no-invalid-this": "off",
-
-            // 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",
-
-            // The non-TypeScript rule produces false positives
-            "func-call-spacing": "off",
-            "@typescript-eslint/func-call-spacing": ["error"],
-
-            "quotes": "off",
-            // We use a `logger` intermediary module
-            "no-console": "error",
-        },
-    }],
-};
+    }
+}
@@ -1,41 +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
-
@@ -1 +0,0 @@
-* @matrix-org/element-web
@@ -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,6 +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@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,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@v2
-        with:
-          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-          repository: ${{ matrix.repo }}
-          event-type: ${{ matrix.event }}
@@ -1,91 +0,0 @@
-name: Pull Request
-on:
-  pull_request_target:
-    types: [ opened, edited, labeled, unlabeled, synchronize ]
-  workflow_call:
-    inputs:
-      labels:
-        type: string
-        default: "T-Defect,T-Deprecation,T-Enhancement,T-Task"
-        required: false
-        description: "No longer used, uses allchange logic now, will be removed at a later date"
-    secrets:
-      ELEMENT_BOT_TOKEN:
-        required: true
-concurrency: ${{ github.workflow }}-${{ github.event.pull_request.head.ref }}
-jobs:
-  changelog:
-    name: Preview Changelog
-    runs-on: ubuntu-latest
-    steps:
-      - uses: matrix-org/allchange@main
-        with:
-          ghToken: ${{ secrets.GITHUB_TOKEN }}
-          requireLabel: true
-
-  prevent-blocked:
-    name: Prevent Blocked
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: read
-    steps:
-      - name: Add notice
-        uses: actions/github-script@v6
-        if: contains(github.event.pull_request.labels.*.name, 'X-Blocked')
-        with:
-          script: |
-            core.setFailed("Preventing merge whilst PR is marked blocked!");
-
-  community-prs:
-    name: Label Community PRs
-    runs-on: ubuntu-latest
-    if: github.event.action == 'opened'
-    steps:
-      - name: Check membership
-        uses: tspascoal/get-user-teams-membership@v1
-        id: teams
-        with:
-          username: ${{ github.event.pull_request.user.login }}
-          organization: matrix-org
-          team: Core Team
-          GITHUB_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}
-
-      - 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,41 +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@v3
-
-      - name: 🔧 Yarn cache
-        uses: actions/setup-node@v3
-        with:
-          cache: "yarn"
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: 🔨 Install dependencies
-        run: "yarn install --pure-lockfile"
-
-      - name: 🚀 Publish to npm
-        id: npm-publish
-        uses: JS-DevTools/npm-publish@v1
-        with:
-          token: ${{ secrets.NPM_TOKEN }}
-          access: public
-          tag: next
-
-      - name: 🎖️ Add `latest` dist-tag to final releases
-        if: github.event.release.prerelease == false
-        run: |
-          package=$(cat package.json | jq -er .name)
-          npm dist-tag add "$package@$release" latest
-        env:
-          # JS-DevTools/npm-publish overrides `NODE_AUTH_TOKEN` with `INPUT_TOKEN` in .npmrc
-          INPUT_TOKEN: ${{ secrets.NPM_TOKEN }}
-          release: ${{ steps.npm-publish.outputs.version }}
@@ -1,58 +0,0 @@
-name: Release Process
-on:
-  release:
-    types: [ published ]
-concurrency: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  jsdoc:
-    name: Publish Documentation
-    runs-on: ubuntu-latest
-    steps:
-      - name: 🧮 Checkout code
-        uses: actions/checkout@v3
-
-      - name: 🔧 Yarn cache
-        uses: actions/setup-node@v3
-        with:
-          cache: "yarn"
-
-      - name: 🔨 Install dependencies
-        run: "yarn install --pure-lockfile"
-
-      - name: 📖 Generate JSDoc
-        run: "yarn gendoc"
-
-      - name: 📋 Copy to temp
-        run: |
-          tag="${{ github.ref_name }}"
-          version="${tag#v}"
-          echo "VERSION=$version" >> $GITHUB_ENV
-          cp -a "./.jsdoc/matrix-js-sdk/$version" $RUNNER_TEMP
-
-      - name: 🧮 Checkout gh-pages
-        uses: actions/checkout@v3
-        with:
-          ref: gh-pages
-
-      - name: 🔪 Prepare
-        run: |
-          cp -a "$RUNNER_TEMP/$VERSION" .
-
-          # Add the new directory to the index if it isn't there already
-          if ! grep -q ">Version $VERSION</a>" index.html; then
-            perl -i -pe 'BEGIN {$rel=shift} $_ =~ /^<\/ul>/ && print
-              "<li><a href=\"${rel}/index.html\">Version ${rel}</a></li>\n"' "$VERSION" index.html
-          fi
-
-      - name: 🚀 Deploy
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          keep_files: true
-          publish_dir: .
-
-  npm:
-    name: Publish
-    uses: matrix-org/matrix-js-sdk/.github/workflows/release-npm.yml@develop
-    secrets:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
@@ -1,45 +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
-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@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.2
-        with:
-          repository: ${{ github.event.workflow_run.head_repository.full_name }}
-          is_pr: ${{ github.event.workflow_run.event == 'pull_request' }}
-          version_cmd: 'cat package.json | jq -r .version'
-          branch: ${{ github.event.workflow_run.head_branch }}
-          revision: ${{ github.event.workflow_run.head_sha }}
-          token: ${{ secrets.SONAR_TOKEN }}
-          coverage_run_id: ${{ github.event.workflow_run.id }}
-          coverage_workflow_name: tests.yml
-          coverage_extract_path: coverage
-          
-      
-      - uses: Sibz/github-status-action@v1
-        if: always()
-        with:
-          authToken: ${{ secrets.GITHUB_TOKEN }}
-          state: ${{ steps.sonarcloud.outcome == 'success' && 'success' || 'failure' }}
-          context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
-          sha: ${{ github.event.workflow_run.head_sha }}
-          target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}
@@ -1,15 +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:
-  sonarqube:
-    name: 🩻 SonarQube
-    uses: matrix-org/matrix-js-sdk/.github/workflows/sonarcloud.yml@develop
-    secrets:
-      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
@@ -1,101 +0,0 @@
-name: Static Analysis
-on:
-  pull_request: { }
-  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@v3
-
-      - 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@v3
-
-      - 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@v3
-
-      - uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
-
-      - name: Install Deps
-        run: "yarn install"
-
-      - name: Generate Docs
-        run: "yarn run gendoc"
-
-  tsc-strict:
-    name: Typescript Strict Error Checker
-    if: github.event_name == 'pull_request'
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: read
-      checks: write
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Get diff lines
-        id: diff
-        uses: Equip-Collaboration/diff-line-numbers@v1.0.0
-        with:
-          include: '["\\.tsx?$"]'
-
-      - name: Detecting files changed
-        id: files
-        uses: futuratrepadeira/changed-files@v4.0.0
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          pattern: '^.*\.tsx?$'
-
-      - uses: t3chguy/typescript-check-action@main
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          use-check: false
-          check-fail-mode: added
-          output-behaviour: annotate
-          ts-extra-args: '--strict'
-          files-changed: ${{ steps.files.outputs.files_updated }}
-          files-added: ${{ steps.files.outputs.files_created }}
-          files-deleted: ${{ steps.files.outputs.files_deleted }}
-          line-numbers: ${{ steps.diff.outputs.lineNumbers }}
@@ -1,37 +0,0 @@
-name: Tests
-on:
-  pull_request: { }
-  push:
-    branches: [ develop, master ]
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-jobs:
-  jest:
-    name: Jest
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Yarn cache
-        uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
-
-      - name: Install dependencies
-        run: "yarn install"
-
-      - name: Build
-        run: "yarn build"
-
-      - name: Run tests with coverage
-        run: "yarn coverage --ci --reporters github-actions"
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: coverage
-          path: |
-            coverage
-            !coverage/lcov-report
@@ -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@v3
-
-      - 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@v4
-        with:
-          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-          branch: actions/upgrade-deps
-          delete-branch: true
-          title: Upgrade dependencies
-          labels: |
-            Dependencies
-            T-Task
-          
-      - name: Enable automerge
-        uses: peter-evans/enable-pull-request-automerge@v2
-        if: steps.cpr.outputs.pull-request-operation == 'created'
-        with:
-          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-          pull-request-number: ${{ steps.cpr.outputs.pull-request-number }}
@@ -2,20 +2,16 @@
 /.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/
@@ -0,0 +1,2 @@
+instrumentation:
+  compact: false
@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+    - "10.11.0"
+script:
+    - ./travis.sh
@@ -1,5 +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,120 @@
+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 :)
+
+If you forgot to sign off your commits before making your pull request and are on git 2.17+ 
+you can mass signoff using rebase::
+
+    git rebase --signoff origin/develop
@@ -1,15 +1,8 @@
-[![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/)

-This is the [Matrix](https://matrix.org) Client-Server r0 SDK for
+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.

 Quickstart
@@ -17,33 +10,22 @@ Quickstart

 In a browser
 ------------
-Download the browser version from
+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
 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
 ----------

-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("https://matrix.org");
+  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));
  });
@@ -74,7 +56,7 @@ client.once('sync', function(state, prevState, res) {
 To send a message:

 ```javascript
-const content = {
+var content = {
    "body": "message text",
    "msgtype": "m.text"
 };
@@ -94,7 +76,7 @@ client.on("Room.timeline", function(event, room, toStartOfTimeline) {
 });
 ```

-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:
+By default, the `matrix-js-sdk` client uses the `MatrixInMemoryStore` 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) => {
@@ -176,7 +158,7 @@ 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) {
    ...
  });
 ```
@@ -188,8 +170,10 @@ you can pass the result of the promise into it with something like:
  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.

@@ -204,10 +188,10 @@ 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({
+   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
@@ -219,7 +203,7 @@ core functionality of the SDK. These examples assume the SDK is setup like this:
 ```javascript
   matrixClient.on("RoomMember.membership", function(event, member) {
       if (member.membership === "invite" && member.userId === myUserId) {
-           matrixClient.joinRoom(member.roomId).then(function() {
+           matrixClient.joinRoom(member.roomId).done(function() {
               console.log("Auto-joined %s", member.roomId);
           });
       }
@@ -260,11 +244,11 @@ Output:

 ```javascript
   matrixClient.on("RoomState.members", function(event, state, member) {
-       const room = matrixClient.getRoom(state.roomId);
+       var room = matrixClient.getRoom(state.roomId);
       if (!room) {
           return;
       }
-       const memberList = state.getMembers();
+       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++) {
@@ -299,9 +283,9 @@ This SDK uses JSDoc3 style comments. You can manually build and
 host the API reference from the source files like this:

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

 Then visit ``http://localhost:8005`` to see the API docs.
@@ -310,10 +294,10 @@ 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
+It is also necessry to call ``matrixClient.initCrypto()`` after creating a new
 ``MatrixClient`` (but **before** calling ``matrixClient.startClient()``) to
 initialise the crypto layer.

@@ -330,20 +314,20 @@ specification.

 To provide the Olm library in a browser application:

- * download the transpiled libolm (from https://packages.matrix.org/npm/olm/).
+ * 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``
+ * ``npm install https://matrix.org/packages/npm/olm/olm-3.0.0.tgz``
   (replace the URL with the latest version you want to use from
-    https://packages.matrix.org/npm/olm/)
+    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-3.0.0.tgz
+--save-optional`` (if your application also works without e2e crypto enabled)
+or ``--save`` (if it doesn't) to do so.


 Contributing
@@ -353,7 +337,7 @@ want to use this SDK, skip this section.*

 First, you need to pull in the right build tools:
 ```
- $ yarn install
+ $ npm install
 ```

 Building
@@ -361,15 +345,20 @@ Building

 To build a browser version from scratch when developing::
 ```
- $ yarn build
+ $ npm run build
+```
+
+To constantly do builds when files are modified (using ``watchify``)::
+```
+ $ npm run watch
 ```

 To run tests (Jasmine)::
 ```
- $ yarn test
+ $ npm test
 ```

 To run linting:
 ```
- $ yarn lint
+ $ npm run lint
 ```
@@ -0,0 +1,35 @@
+var matrixcs = require("./lib/matrix");
+const request = require('browser-request');
+const queryString = require('qs');
+
+matrixcs.request(function(opts, fn) {
+    // We manually fix the query string for browser-request because
+    // it doesn't correctly handle cases like ?via=one&via=two. Instead
+    // we mimic `request`'s query string interface to make it all work
+    // as expected.
+    // browser-request will happily take the constructed string as the
+    // query string without trying to modify it further.
+    opts.qs = queryString.stringify(opts.qs || {}, opts.qsStringifyOptions);
+    return request(opts, fn);
+});
+
+// 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,6 +1,7 @@
+"use strict";
 console.log("Loading browser sdk");

-var client = matrixcs.createClient("https://matrix.org");
+var client = matrixcs.createClient("http://matrix.org");
 client.publicRooms(function (err, data) {
    if (err) {
 	   console.error("err %s", JSON.stringify(err));
@@ -1,8 +1,6 @@
-<html lang="en">
+<html>
 <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>
@@ -1,2 +0,0 @@
-olm.js
-olm.wasm
@@ -1 +0,0 @@
-../../../dist/browser-matrix.js
@@ -1,59 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>Test Crypto in Browser</title>
-    <script src="lib/olm.js"></script>
-    <script src="lib/matrix.js"></script>
-</head>
-<body>
-    <h1>Testing export/import of Olm devices in the browser</h1>
-    <ul>
-        <li>
-            Make sure you built the current version of the Matrix JS SDK
-            (<code>yarn build</code>)
-        </li>
-        <li>
-            copy <code>olm.js</code> and <code>olm.wasm</code>
-            from a recent release of Olm (was tested with version 3.1.4)
-            in directory <code>lib/</code>
-        </li>
-        <li>start a local Matrix homeserver (on port 8008, or change the port in the code)</li>
-        <li>Serve this HTML file (e.g. <code>python3 -m http.server</code>) and go to it through your browser</li>
-        <li>
-            in the JS console, do:
-            <pre>
-aliceMatrixClient = await newMatrixClient("alice-"+randomHex());
-await aliceMatrixClient.exportDevice();
-await aliceMatrixClient.getAccessToken();
-            </pre>
-        </li>
-        <li>
-            copy the result of <code>exportDevice</code> and <code>getAccessToken</code> somewhere
-            (<strong>not</strong> in a JS variable as it will be destroyed when you refresh the page)
-        </li>
-        <li><strong>refresh the page (F5)</strong> to make sure the client is destroyed</li>
-        <li>
-            Do the following, replacing <code>ALICE_ID</code>
-            with the user ID of Alice (you can find it in the exported data)
-            <pre>
-bobMatrixClient = await newMatrixClient("bob-"+randomHex());
-roomId = await bobMatrixClient.createEncryptedRoom([ALICE_ID]);
-await bobMatrixClient.sendTextMessage('Hi Alice!', roomId);
-            </pre>
-        </li>
-        <li>Again, <strong>refresh the page (F5)</strong>. You may want to clear your console as well.</li>
-        <li>
-            Now do the following, using the exported data and the access token you saved previously:
-            <pre>
-aliceMatrixClient = await importMatrixClient(EXPORTED_DATA, ACCESS_TOKEN);
-            </pre>
-        </li>
-        <li>You should see the message sent by Bob printed in the console.</li>
-    </ul>
-
-    <script src="olm-device-export-import.js"></script>
-</body>
-</html>
@@ -1,122 +0,0 @@
-if (!Olm) {
-    console.error(
-        "global.Olm does not seem to be present."
-        + " Did you forget to add olm in the lib/ directory?"
-    );
-}
-
-const BASE_URL = 'http://localhost:8008';
-const ROOM_CRYPTO_CONFIG = { algorithm: 'm.megolm.v1.aes-sha2' };
-const PASSWORD = 'password';
-
-// useful to create new usernames
-window.randomHex = () => Math.floor(Math.random() * (10**6)).toString(16);
-
-window.newMatrixClient = async function (username) {
-    const registrationClient = matrixcs.createClient(BASE_URL);
-
-    const userRegisterResult = await registrationClient.register(
-      username,
-      PASSWORD,
-      null,
-      { type: 'm.login.dummy' }
-    );
-  
-    const matrixClient = matrixcs.createClient({
-      baseUrl: BASE_URL,
-      userId: userRegisterResult.user_id,
-      accessToken: userRegisterResult.access_token,
-      deviceId: userRegisterResult.device_id,
-      sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
-      cryptoStore: new matrixcs.MemoryCryptoStore(),
-    });
-
-    extendMatrixClient(matrixClient);
-
-    await matrixClient.initCrypto();
-    await matrixClient.startClient();
-    return matrixClient;
-}
-
-window.importMatrixClient = async function (exportedDevice, accessToken) {
-    const matrixClient = matrixcs.createClient({
-      baseUrl: BASE_URL,
-      deviceToImport: exportedDevice,
-      accessToken,
-      sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
-      cryptoStore: new matrixcs.MemoryCryptoStore(),
-    });
-
-    extendMatrixClient(matrixClient);
-
-    await matrixClient.initCrypto();
-    await matrixClient.startClient();
-    return matrixClient;
-}
-
-function extendMatrixClient(matrixClient) {
-    // automatic join
-    matrixClient.on('RoomMember.membership', async (event, member) => {
-        if (member.membership === 'invite' && member.userId === matrixClient.getUserId()) {
-            await matrixClient.joinRoom(member.roomId);
-            // setting up of room encryption seems to be triggered automatically
-            // but if we don't wait for it the first messages we send are unencrypted
-            await matrixClient.setRoomEncryption(member.roomId, { algorithm: 'm.megolm.v1.aes-sha2' })
-        }
-    });
-
-    matrixClient.onDecryptedMessage = message => {
-        console.log('Got encrypted message: ', message);
-    }
-
-    matrixClient.on('Event.decrypted', (event) => {
-        if (event.getType() === 'm.room.message'){
-            matrixClient.onDecryptedMessage(event.getContent().body);
-        } else {
-            console.log('decrypted an event of type', event.getType());
-            console.log(event);
-        }
-    });
-  
-    matrixClient.createEncryptedRoom = async function(usersToInvite) {
-        const {
-          room_id: roomId,
-        } = await this.createRoom({
-          visibility: 'private',
-          invite: usersToInvite,
-        });
-
-        // matrixClient.setRoomEncryption() only updates local state
-        // but does not send anything to the server
-        // (see https://github.com/matrix-org/matrix-js-sdk/issues/905)
-        // so we do it ourselves with 'sendStateEvent'
-        await this.sendStateEvent(
-          roomId, 'm.room.encryption', ROOM_CRYPTO_CONFIG,
-        );
-        await this.setRoomEncryption(
-          roomId, ROOM_CRYPTO_CONFIG,
-        );
-
-        // Marking all devices as verified
-        let room = this.getRoom(roomId);
-        let members = (await room.getEncryptionTargetMembers()).map(x => x["userId"])
-        let memberkeys = await this.downloadKeys(members);
-        for (const userId in memberkeys) {
-          for (const deviceId in memberkeys[userId]) {
-            await this.setDeviceVerified(userId, deviceId);
-          }
-        }
-
-        return roomId;
-    }
-
-    matrixClient.sendTextMessage = async function(message, roomId) {
-        return matrixClient.sendMessage(
-            roomId,
-            {
-                body: message,
-                msgtype: 'm.text',
-            }
-        )
-    }
-}
@@ -1,3 +1,5 @@
+"use strict";
+
 var myUserId = "@example:localhost";
 var myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
 var sdk = require("matrix-js-sdk");
@@ -54,7 +56,7 @@ rl.on('line', function(line) {
                }
            }
            if (notSentEvent) {
-                matrixClient.resendEvent(notSentEvent, viewingRoom).then(function() {
+                matrixClient.resendEvent(notSentEvent, viewingRoom).done(function() {
                    printMessages();
                    rl.prompt();
                }, function(err) {
@@ -68,7 +70,7 @@ rl.on('line', function(line) {
        }
        else if (line.indexOf("/more ") === 0) {
            var amount = parseInt(line.split(" ")[1]) || 20;
-            matrixClient.scrollback(viewingRoom, amount).then(function(room) {
+            matrixClient.scrollback(viewingRoom, amount).done(function(room) {
                printMessages();
                rl.prompt();
            }, function(err) {
@@ -77,7 +79,7 @@ rl.on('line', function(line) {
        }
        else if (line.indexOf("/invite ") === 0) {
            var userId = line.split(" ")[1].trim();
-            matrixClient.invite(viewingRoom.roomId, userId).then(function() {
+            matrixClient.invite(viewingRoom.roomId, userId).done(function() {
                printMessages();
                rl.prompt();
            }, function(err) {
@@ -90,7 +92,7 @@ rl.on('line', function(line) {
            matrixClient.uploadContent({
                stream: stream,
                name: filename
-            }).then(function(url) {
+            }).done(function(url) {
                var content = {
                    msgtype: "m.file",
                    body: filename,
@@ -114,7 +116,7 @@ rl.on('line', function(line) {
            viewingRoom = roomList[roomIndex];
            if (viewingRoom.getMember(myUserId).membership === "invite") {
                // join the room first
-                matrixClient.joinRoom(viewingRoom.roomId).then(function(room) {
+                matrixClient.joinRoom(viewingRoom.roomId).done(function(room) {
                    setRoomList();
                    viewingRoom = room;
                    printMessages();
@@ -126,7 +128,7 @@ rl.on('line', function(line) {
            else {
                printMessages();
            }
-        }
+        } 
    }
    rl.prompt();
 });
@@ -279,8 +281,8 @@ function printMemberList(room) {
            member.membership + new Array(10 - member.membership.length).join(" ")
        );
        print(
-            "%s"+fmt(" :: ")+"%s"+fmt(" (")+"%s"+fmt(")"),
-            membershipWithPadding, member.name,
+            "%s"+fmt(" :: ")+"%s"+fmt(" (")+"%s"+fmt(")"), 
+            membershipWithPadding, member.name, 
            (member.userId === myUserId ? "Me" : member.userId),
            fmt
        );
@@ -288,27 +290,26 @@ function printMemberList(room) {
 }

 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 -
+        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(new Array(100).join("-"));
-    eventMap.keys().forEach(function(eventType) {
+    Object.keys(eventDict).forEach(function(eventType) {
        if (eventType === "m.room.member") { return; } // use /members instead.
-        var eventEventMap = eventMap.get(eventType);
-        eventEventMap.keys().forEach(function(stateKey) {
+        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
@@ -341,7 +342,7 @@ 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") {
@@ -398,7 +399,7 @@ function print(str, formatter) {

 function fixWidth(str, len) {
    if (str.length > len) {
-        return str.substring(0, len-2) + "\u2026";
+        return str.substr(0, len-2) + "\u2026";
    }
    else if (str.length < len) {
        return str + new Array(len - str.length).join(" ");
@@ -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,7 +20,7 @@ function disableButtons(place, answer, hangup) {
 }

 function addListeners(call) {
-    let lastError = "";
+    var lastError = "";
    call.on("hangup", function() {
        disableButtons(false, true, true);
        document.getElementById("result").innerHTML = (
@@ -32,23 +32,6 @@ function addListeners(call) {
        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() {
@@ -80,7 +63,10 @@ function syncComplete() {
        );
        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);
    };
@@ -1,34 +1,26 @@
 <html>
-
 <head>
-    <title>VoIP Test</title>
-    <script src="lib/matrix.js"></script>
-    <script src="browserTest.js"></script>
+<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
+	You can place and receive calls with this example. Make sure to edit the
    constants in <code>browserTest.js</code> first.
    <div id="config"></div>
    <div id="result"></div>
    <button id="call">Place Call</button>
    <button id="answer">Answer Call</button>
    <button id="hangup">Hangup Call</button>
-    <div id="videoBackground" class="video-background">
-        <video class="video-element" id="local"></video>
-        <video class="video-element" id="remote"></video>
+    <div id="videoBackground">
+        <div id="videoContainer">
+            <video id="remote"></video>
+        </div>
+    </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 10 || 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,30 +0,0 @@
-{
-  "tags": {
-    "allowUnknownTags": true
-  },
-  "plugins": [
-    "node_modules/better-docs/category",
-    "node_modules/better-docs/typescript"
-  ],
-  "source": {
-    "include": [
-      "src"
-    ],
-    "includePattern": ".(ts|js)$"
-  },
-  "opts": {
-    "encoding": "utf8",
-    "destination": ".jsdoc",
-    "readme": "README.md",
-    "recurse": true,
-    "verbose": true,
-    "template": "node_modules/docdash"
-  },
-  "docdash": {
-    "static": true,
-    "private": false,
-    "search": true,
-    "collapse": true,
-    "typedefs": true
-  }
-}
@@ -1,29 +1,24 @@
 {
  "name": "matrix-js-sdk",
-  "version": "21.1.0-rc.1",
+  "version": "0.14.3",
  "description": "Matrix Client-Server SDK for Javascript",
-  "engines": {
-    "node": ">=16.0.0"
-  },
+  "main": "index.js",
  "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",
+    "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": "npm run start:init && npm run start:watch",
+    "start:watch": "babel -s -w --skip-initial-build -d lib src",
+    "start:init": "babel -s -d lib src",
    "clean": "rimraf lib dist",
-    "build": "yarn build:dev && yarn build:compile-browser && yarn build:minify-browser",
-    "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
-    "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
-    "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
-    "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.js -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
-    "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
-    "gendoc": "jsdoc -c jsdoc.json -P package.json",
-    "lint": "yarn lint:types && yarn lint:js",
-    "lint:js": "eslint --max-warnings 0 src spec",
-    "lint:js-fix": "eslint --fix src spec",
-    "lint:types": "tsc --noEmit",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "coverage": "yarn test --coverage"
+    "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 101 src spec",
+    "prepublish": "npm run clean && npm run build && git rev-parse HEAD > git-revision.txt"
  },
  "repository": {
    "type": "git",
@@ -32,104 +27,69 @@
  "keywords": [
    "matrix-org"
  ],
-  "main": "./lib/index.js",
-  "browser": "./lib/browser-index.js",
-  "matrix_src_main": "./src/index.ts",
-  "matrix_src_browser": "./src/browser-index.js",
-  "matrix_lib_main": "./lib/index.js",
-  "matrix_lib_typings": "./lib/index.d.ts",
+  "browser": "browser-index.js",
  "author": "matrix.org",
  "license": "Apache-2.0",
  "files": [
-    "dist",
-    "lib",
-    "src",
-    "git-revision.txt",
+    ".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"
+    "release.sh",
+    "spec",
+    "src"
  ],
  "dependencies": {
-    "@babel/runtime": "^7.12.5",
    "another-json": "^0.2.0",
-    "bs58": "^5.0.0",
-    "content-type": "^1.0.4",
-    "loglevel": "^1.7.1",
-    "matrix-events-sdk": "^0.0.1-beta.7",
-    "p-retry": "4",
-    "qs": "^6.9.6",
-    "unhomoglyph": "^1.0.6"
+    "babel-runtime": "^6.26.0",
+    "base-x": "3.0.4",
+    "bluebird": "^3.5.0",
+    "browser-request": "^0.3.3",
+    "bs58": "^4.0.1",
+    "content-type": "^1.0.2",
+    "loglevel": "1.6.1",
+    "qs": "^6.5.2",
+    "request": "^2.88.0",
+    "unhomoglyph": "^1.0.2"
  },
  "devDependencies": {
-    "@babel/cli": "^7.12.10",
-    "@babel/core": "^7.12.10",
-    "@babel/eslint-parser": "^7.12.10",
-    "@babel/eslint-plugin": "^7.12.10",
-    "@babel/plugin-proposal-class-properties": "^7.12.1",
-    "@babel/plugin-proposal-numeric-separator": "^7.12.7",
-    "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
-    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-    "@babel/plugin-transform-runtime": "^7.12.10",
-    "@babel/preset-env": "^7.12.11",
-    "@babel/preset-typescript": "^7.12.7",
-    "@babel/register": "^7.12.10",
-    "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.13.tgz",
-    "@types/bs58": "^4.0.1",
-    "@types/content-type": "^1.1.5",
-    "@types/domexception": "^4.0.0",
-    "@types/jest": "^29.0.0",
-    "@types/node": "16",
-    "@typescript-eslint/eslint-plugin": "^5.6.0",
-    "@typescript-eslint/parser": "^5.6.0",
-    "allchange": "^1.0.6",
-    "babel-jest": "^29.0.0",
-    "babelify": "^10.0.0",
-    "better-docs": "^2.4.0-beta.9",
-    "browserify": "^17.0.0",
-    "docdash": "^1.2.0",
-    "domexception": "^4.0.0",
-    "eslint": "8.25.0",
-    "eslint-config-google": "^0.14.0",
-    "eslint-import-resolver-typescript": "^3.5.1",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-matrix-org": "^0.7.0",
-    "eslint-plugin-unicorn": "^44.0.2",
-    "exorcist": "^2.0.0",
-    "fake-indexeddb": "^4.0.0",
-    "jest": "^29.0.0",
-    "jest-localstorage-mock": "^2.4.6",
-    "jest-mock": "^29.0.0",
-    "jest-sonar-reporter": "^2.0.0",
-    "jsdoc": "^3.6.6",
-    "matrix-mock-request": "^2.5.0",
-    "rimraf": "^3.0.2",
-    "terser": "^5.5.1",
-    "tsify": "^5.0.2",
-    "typescript": "^4.5.3"
+    "babel-cli": "^6.18.0",
+    "babel-plugin-transform-async-to-bluebird": "^1.1.1",
+    "babel-plugin-transform-runtime": "^6.23.0",
+    "babel-preset-es2015": "^6.18.0",
+    "browserify": "^16.2.3",
+    "browserify-shim": "^3.8.13",
+    "eslint": "^5.12.0",
+    "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.2",
+    "mocha": "^5.2.0",
+    "mocha-jenkins-reporter": "^0.4.0",
+    "rimraf": "^2.5.4",
+    "source-map-support": "^0.4.11",
+    "sourceify": "^0.1.0",
+    "uglify-js": "^2.8.26",
+    "watchify": "^3.11.0"
  },
-  "jest": {
-    "testEnvironment": "node",
-    "testMatch": [
-      "<rootDir>/spec/**/*.spec.{js,ts}"
-    ],
-    "setupFilesAfterEnv": [
-      "<rootDir>/spec/setupTests.ts"
-    ],
-    "collectCoverageFrom": [
-      "<rootDir>/src/**/*.{js,ts}"
-    ],
-    "coverageReporters": [
-      "text-summary",
-      "lcov"
-    ],
-    "testResultsProcessor": "jest-sonar-reporter"
-  },
-  "jestSonar": {
-    "reportPath": "coverage",
-    "sonar56x": true
-  },
-  "typings": "./lib/index.d.ts"
+  "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
-    do
-        # If a `lib` prefixed value is present, it means we adjusted the field
-        # earlier at publish time, so we should revert it now.
-        if [ "$(jq -r ".matrix_lib_$i" package.json)" != "null" ]; then
-            # If there's a `src` prefixed value, use that, otherwise delete.
-            # This is used to delete the `typings` field and reset `main` back
-            # to the TypeScript source.
-            src_value=$(jq -r ".matrix_src_$i" package.json)
-            if [ "$src_value" != "null" ]; then
-                jq ".$i = .matrix_src_$i" package.json > package.json.new && mv package.json.new package.json
-            else
-                jq "del(.$i)" package.json > package.json.new && mv package.json.new package.json
-            fi
-        fi
-    done
-
-    if [ -n "$(git ls-files --modified package.json)" ]; then
-        echo "Committing develop package.json"
-        git commit package.json -m "Resetting package fields for development"
-    fi
-
-    git push origin develop
-fi
@@ -1,18 +1,17 @@
 #!/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
+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
@@ -23,9 +22,8 @@ else
    echo "hub is required: please install it"
    exit
 fi
-yarn --version > /dev/null || (echo "yarn 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 +31,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 +53,10 @@ if ! git diff-files --quiet; then
 fi

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

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

-function check_dependency {
-    local depver=$(cat package.json | jq -r .dependencies[\"$1\"])
-    if [ "$depver" == "null" ]; then return 0; fi
-
-    echo "Checking version of $1..."
-    local latestver=$(yarn info -s "$1" dist-tags.next)
-    if [ "$depver" != "$latestver" ]
-    then
-        echo "The latest version of $1 is $latestver but package.json depends on $depver."
-        echo -n "Type 'u' to auto-upgrade, 'c' to continue anyway, or 'a' to abort:"
-        read resp
-        if [ "$resp" != "u" ] && [ "$resp" != "c" ]
-        then
-            echo "Aborting."
-            exit 1
-        fi
-        if [ "$resp" == "u" ]
-        then
-            echo "Upgrading $1 to $latestver..."
-            yarn add -E "$1@$latestver"
-            git add -u
-            git commit -m "Upgrade $1 to $latestver"
-        fi
-    fi
-}
-
-function reset_dependency {
-    local depver=$(cat package.json | jq -r .dependencies[\"$1\"])
-    if [ "$depver" == "null" ]; then return 0; fi
-
-    echo "Resetting $1 to develop branch..."
-    yarn add "github:matrix-org/$1#develop"
-    git add -u
-    git commit -m "Reset $1 back to develop branch"
-}
-
-has_subprojects=0
-if [ -f release_config.yaml ]; then
-    subprojects=$(cat release_config.yaml | python -c "import yaml; import sys; print(' '.join(list(yaml.load(sys.stdin)['subprojects'].keys())))" 2> /dev/null)
-    if [ "$?" -eq 0 ]; then
-        has_subprojects=1
-        echo "Checking subprojects for upgrades"
-        for proj in $subprojects; do
-            check_dependency "$proj"
-        done
-    fi
+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
+actual_npm_user=`npm whoami`;
+if [ $expected_npm_user != $actual_npm_user ]; then
+    echo "you need to be logged into npm as $expected_npm_user, but you are logged in as $actual_npm_user" >&2
+    exit 1
 fi

-# We use Git branch / commit dependencies for some packages, and Yarn seems
-# to have a hard time getting that right. See also
-# https://github.com/yarnpkg/yarn/issues/4734. As a workaround, we clean the
-# global cache here to ensure we get the right thing.
-yarn cache clean
-# Ensure all dependencies are updated
-yarn install --ignore-scripts --pure-lockfile
-
 # 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 +108,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 +141,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
-do
-    lib_value=$(jq -r ".matrix_lib_$i" package.json)
-    if [ "$lib_value" != "null" ]; then
-        jq ".$i = .matrix_lib_$i" package.json > package.json.new && mv package.json.new package.json
-    fi
-done
-
-# commit yarn.lock if it exists, is versioned, and is modified
-if [[ -f yarn.lock && $(git status --porcelain yarn.lock | grep '^ M') ]];
-then
-    pkglock='yarn.lock'
-else
-    pkglock=''
-fi
-git commit package.json $pkglock -m "$tag"
+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 +170,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 --pure-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 +201,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 +221,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,7 +261,7 @@ if [ $prerelease -eq 1 ]; then
    hubflags='-p'
 fi

-release_text=$(mktemp)
+release_text=`mktemp`
 echo "$tag" > "${release_text}"
 echo >> "${release_text}"
 cat "${latest_changes}" >> "${release_text}"
@@ -323,6 +273,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 +301,16 @@ fi
 echo "updating master branch"
 git checkout master
 git pull
-git merge "$rel_branch" --no-edit
+git merge "$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
@@ -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/test-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,225 @@
+/*
+Copyright 2016 OpenMarket Ltd
+Copyright 2017 Vector Creations Ltd
+Copyright 2018 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.
+*/
+
+"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';
+import LocalStorageCryptoStore from '../lib/crypto/store/localStorage-crypto-store';
+
+/**
+ * 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();
+    }
+    const sessionStore = new sdk.WebStorageSessionStore(sessionStoreBackend);
+
+    // expose this so the tests can get to it
+    this.cryptoStore = new LocalStorageCryptoStore(sessionStoreBackend);
+
+    this.httpBackend = new MockHttpBackend();
+    this.client = sdk.createClient({
+        baseUrl: "http://" + userId + ".test.server",
+        userId: userId,
+        accessToken: accessToken,
+        deviceId: deviceId,
+        sessionStore: sessionStore,
+        cryptoStore: this.cryptoStore,
+        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
+ * @return {Promise} Resolves once the mock http backend has finished all pending flushes
+ */
+TestClient.prototype.stop = function() {
+    this.client.stopClient();
+    return this.httpBackend.stop();
+};
+
+/**
+ * Set up expectations that the client will upload device keys.
+ */
+TestClient.prototype.expectDeviceKeyUpload = function() {
+    const self = this;
+    this.httpBackend.when("POST", "/keys/upload").respond(200, function(path, content) {
+        expect(content.one_time_keys).toBe(undefined);
+        expect(content.device_keys).toBeTruthy();
+
+        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,242 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-Copyright 2017 Vector Creations Ltd
-Copyright 2018-2019 New Vector Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// load olm before the sdk if possible
-import './olm-loader';
-
-import MockHttpBackend from 'matrix-mock-request';
-
-import { LocalStorageCryptoStore } from '../src/crypto/store/localStorage-crypto-store';
-import { logger } from '../src/logger';
-import { syncPromise } from "./test-utils/test-utils";
-import { createClient } from "../src/matrix";
-import { ICreateClientOpts, IDownloadKeyResult, MatrixClient, PendingEventOrdering } from "../src/client";
-import { MockStorageApi } from "./MockStorageApi";
-import { encodeUri } from "../src/utils";
-import { IDeviceKeys, IOneTimeKey } from "../src/crypto/dehydration";
-import { IKeyBackupSession } from "../src/crypto/keybackup";
-import { IKeysUploadResponse, IUploadKeysRequest } from '../src/client';
-
-/**
- * Wrapper for a MockStorageApi, MockHttpBackend and MatrixClient
- */
-export class TestClient {
-    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(): Promise<void> {
-        logger.log(this + ': starting');
-        this.httpBackend.when("GET", "/versions").respond(200, {});
-        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,
-        });
-
-        return Promise.all([
-            this.httpBackend.flushAllExpected(),
-            syncPromise(this.client),
-        ]).then(() => {
-            logger.log(this + ': started');
-        });
-    }
-
-    /**
-     * stop the client
-     * @return {Promise} Resolves once the mock http backend has finished all pending flushes
-     */
-    public async stop(): Promise<void> {
-        this.client.stopClient();
-        await this.httpBackend.stop();
-    }
-
-    /**
-     * Set up expectations that the client will upload device keys.
-     */
-    public expectDeviceKeyUpload() {
-        this.httpBackend.when("POST", "/keys/upload")
-            .respond<IKeysUploadResponse, IUploadKeysRequest>(200, (_path, content) => {
-                expect(content.one_time_keys).toBe(undefined);
-                expect(content.device_keys).toBeTruthy();
-
-                logger.log(this + ': received device keys');
-                // 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;
-                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
-     */
-    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 {Object} response   response to the query.
-     */
-    public expectKeyQuery(response: IDownloadKeyResult) {
-        this.httpBackend.when('POST', '/keys/query').respond<IDownloadKeyResult>(
-            200, (_path, content) => {
-                Object.keys(response.device_keys).forEach((userId) => {
-                    expect(content.device_keys![userId]).toEqual([]);
-                });
-                return response;
-            });
-    }
-
-    /**
-     * Set up expectations that the client will query key backups for a particular session
-     */
-    public expectKeyBackupQuery(roomId: string, sessionId: string, status: number, response: IKeyBackupSession) {
-        this.httpBackend.when('GET', encodeUri("/room_keys/keys/$roomId/$sessionId", {
-            $roomId: roomId,
-            $sessionId: sessionId,
-        })).respond(status, response);
-    }
-
-    /**
-     * get the uploaded curve25519 device key
-     *
-     * @return {string} base64 device key
-     */
-    public getDeviceKey(): string {
-        const keyId = 'curve25519:' + this.deviceId;
-        return this.deviceKeys!.keys[keyId];
-    }
-
-    /**
-     * get the uploaded ed25519 device key
-     *
-     * @return {string} base64 device key
-     */
-    public getSigningKey(): string {
-        const keyId = 'ed25519:' + this.deviceId;
-        return this.deviceKeys!.keys[keyId];
-    }
-
-    /**
-     * flush a single /sync request, and wait for the syncing event
-     */
-    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,25 +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.
-*/
-
-// stub for browser-matrix browserify tests
-// @ts-ignore
-global.XMLHttpRequest = jest.fn();
-
-afterAll(() => {
-    // clean up XMLHttpRequest mock
-    // @ts-ignore
-    global.XMLHttpRequest = undefined;
-});
@@ -1,106 +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";
-import "../../dist/browser-matrix"; // uses browser-matrix instead of the src
-import type { MatrixClient, ClientEvent } 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";
-
-declare global {
-    // eslint-disable-next-line @typescript-eslint/no-namespace
-    namespace NodeJS {
-        interface Global {
-            matrixcs: {
-                MatrixClient: typeof MatrixClient;
-                ClientEvent: typeof ClientEvent;
-            };
-        }
-    }
-}
-
-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: {},
-            },
-        };
-        syncData.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,7 +1,6 @@
 /*
 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.
@@ -16,9 +15,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { TestClient } from '../TestClient';
-import * as testUtils from '../test-utils/test-utils';
-import { logger } from '../../src/logger';
+import expect from 'expect';
+import Promise from 'bluebird';
+
+import TestClient from '../TestClient';
+import testUtils from '../test-utils';

 const ROOM_ID = "!room:id";

@@ -67,9 +68,10 @@ function getSyncResponse(roomMembers) {
    return syncResponse;
 }

+
 describe("DeviceList management:", function() {
    if (!global.Olm) {
-        logger.warn('not running deviceList tests: Olm not present');
+        console.warn('not running deviceList tests: Olm not present');
        return;
    }

@@ -85,6 +87,8 @@ describe("DeviceList management:", function() {
    }

    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();
@@ -97,14 +101,13 @@ describe("DeviceList management:", function() {
    });

    it("Alice shouldn't do a second /query for non-e2e-capable devices", function() {
-        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
        return aliceTestClient.start().then(function() {
            const syncResponse = getSyncResponse(['@bob:xyz']);
            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);

            return aliceTestClient.flushSync();
        }).then(function() {
-            logger.log("Forcing alice to download our device keys");
+            console.log("Forcing alice to download our device keys");

            aliceTestClient.httpBackend.when('POST', '/keys/query').respond(200, {
                device_keys: {
@@ -117,12 +120,12 @@ describe("DeviceList management:", function() {
                aliceTestClient.httpBackend.flush('/keys/query', 1),
            ]);
        }).then(function() {
-            logger.log("Telling alice to send a megolm message");
+            console.log("Telling alice to send a megolm message");

            aliceTestClient.httpBackend.when(
                'PUT', '/send/',
            ).respond(200, {
-                event_id: '$event_id',
+                    event_id: '$event_id',
            });

            return Promise.all([
@@ -136,139 +139,140 @@ describe("DeviceList management:", function() {
        });
    });

-    it.skip("We should not get confused by out-of-order device query responses", () => {
-        // https://github.com/vector-im/element-web/issues/3126
-        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
-        return aliceTestClient.start().then(() => {
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(
-                200, getSyncResponse(['@bob:xyz', '@chris:abc']));
-            return aliceTestClient.flushSync();
-        }).then(() => {
-            // to make sure the initial device queries are flushed out, we
-            // attempt to send a message.

-            aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-                200, {
-                    device_keys: {
-                        '@bob:xyz': {},
-                        '@chris:abc': {},
-                    },
-                },
-            );
+    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('PUT', '/send/').respond(
-                200, { event_id: '$event1' });
+               aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
+                   200, {
+                       device_keys: {
+                           '@bob:xyz': {},
+                           '@chris:abc': {},
+                       },
+                   },
+               );

-            return Promise.all([
-                aliceTestClient.client.sendTextMessage(ROOM_ID, 'test'),
-                aliceTestClient.httpBackend.flush('/keys/query', 1).then(
-                    () => aliceTestClient.httpBackend.flush('/send/', 1),
-                ),
-                aliceTestClient.client.crypto.deviceList.saveIfDirty(),
-            ]);
-        }).then(() => {
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                expect(data.syncToken).toEqual(1);
-            });
+               aliceTestClient.httpBackend.when('PUT', '/send/').respond(
+                   200, {event_id: '$event1'});

-            // invalidate bob's and chris's device lists in separate syncs
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, {
-                next_batch: '2',
-                device_lists: {
-                    changed: ['@bob:xyz'],
-                },
-            });
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, {
-                next_batch: '3',
-                device_lists: {
-                    changed: ['@chris:abc'],
-                },
-            });
-            // flush both syncs
-            return aliceTestClient.flushSync().then(() => {
-                return aliceTestClient.flushSync();
-            });
-        }).then(() => {
-            // check that we don't yet have a request for chris's devices.
-            aliceTestClient.httpBackend.when('POST', '/keys/query', {
-                device_keys: {
-                    '@chris:abc': {},
-                },
-                token: '3',
-            }).respond(200, {
-                device_keys: { '@chris:abc': {} },
-            });
-            return aliceTestClient.httpBackend.flush('/keys/query', 1);
-        }).then((flushed) => {
-            expect(flushed).toEqual(0);
-            return aliceTestClient.client.crypto.deviceList.saveIfDirty();
-        }).then(() => {
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
-                if (bobStat != 1 && bobStat != 2) {
-                    throw new Error('Unexpected status for bob: wanted 1 or 2, got ' +
-                        bobStat);
-                }
-                const chrisStat = data.trackingStatus['@chris:abc'];
-                if (chrisStat != 1 && chrisStat != 2) {
-                    throw new Error(
-                        'Unexpected status for chris: wanted 1 or 2, got ' + chrisStat,
-                    );
-                }
-            });
+               return Promise.all([
+                   aliceTestClient.client.sendTextMessage(ROOM_ID, 'test'),
+                   aliceTestClient.httpBackend.flush('/keys/query', 1).then(
+                       () => aliceTestClient.httpBackend.flush('/send/', 1),
+                   ),
+                   aliceTestClient.client._crypto._deviceList.saveIfDirty(),
+               ]);
+           }).then(() => {
+               aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
+                   expect(data.syncToken).toEqual(1);
+               });

-            // 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);
+               // invalidate bob's and chris's device lists in separate syncs
+               aliceTestClient.httpBackend.when('GET', '/sync').respond(200, {
+                   next_batch: '2',
+                   device_lists: {
+                       changed: ['@bob:xyz'],
+                   },
+               });
+               aliceTestClient.httpBackend.when('GET', '/sync').respond(200, {
+                   next_batch: '3',
+                   device_lists: {
+                       changed: ['@chris:abc'],
+                   },
+               });
+               // flush both syncs
+               return aliceTestClient.flushSync().then(() => {
+                   return aliceTestClient.flushSync();
+               });
+           }).then(() => {
+               // check that we don't yet have a request for chris's devices.
+               aliceTestClient.httpBackend.when('POST', '/keys/query', {
+                   device_keys: {
+                       '@chris:abc': {},
+                   },
+                   token: '3',
+               }).respond(200, {
+                   device_keys: {'@chris:abc': {}},
+               });
+               return aliceTestClient.httpBackend.flush('/keys/query', 1);
+           }).then((flushed) => {
+               expect(flushed).toEqual(0);
+               return aliceTestClient.client._crypto._deviceList.saveIfDirty();
+           }).then(() => {
+               aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
+                   const bobStat = data.trackingStatus['@bob:xyz'];
+                   if (bobStat != 1 && bobStat != 2) {
+                       throw new Error('Unexpected status for bob: wanted 1 or 2, got ' +
+                                       bobStat);
+                   }
+                   const chrisStat = data.trackingStatus['@chris:abc'];
+                   if (chrisStat != 1 && chrisStat != 2) {
+                       throw new Error(
+                           'Unexpected status for chris: wanted 1 or 2, got ' + chrisStat,
+                       );
+                   }
+               });

-            // wait for the client to stop processing the response
-            return aliceTestClient.client.downloadKeys(['@bob:xyz']);
-        }).then(() => {
-            return aliceTestClient.client.crypto.deviceList.saveIfDirty();
-        }).then(() => {
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
-                expect(bobStat).toEqual(3);
-                const chrisStat = data.trackingStatus['@chris:abc'];
-                if (chrisStat != 1 && chrisStat != 2) {
-                    throw new Error(
-                        'Unexpected status for chris: wanted 1 or 2, got ' + bobStat,
-                    );
-                }
-            });
+               // now 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);

-            // 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(['@bob:xyz']);
+           }).then(() => {
+               return aliceTestClient.client._crypto._deviceList.saveIfDirty();
+           }).then(() => {
+               aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
+                   const bobStat = data.trackingStatus['@bob:xyz'];
+                   expect(bobStat).toEqual(3);
+                   const chrisStat = data.trackingStatus['@chris:abc'];
+                   if (chrisStat != 1 && chrisStat != 2) {
+                       throw new Error(
+                           'Unexpected status for chris: wanted 1 or 2, got ' + bobStat,
+                       );
+                   }
+               });

-            // wait for the client to stop processing the response
-            return aliceTestClient.client.downloadKeys(['@chris:abc']);
-        }).then(() => {
-            return aliceTestClient.client.crypto.deviceList.saveIfDirty();
-        }).then(() => {
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
-                const chrisStat = data.trackingStatus['@bob:xyz'];
+               // now let the query for chris's devices complete.
+               return aliceTestClient.httpBackend.flush('/keys/query', 1);
+           }).then((flushed) => {
+               expect(flushed).toEqual(1);

-                expect(bobStat).toEqual(3);
-                expect(chrisStat).toEqual(3);
-                expect(data.syncToken).toEqual(3);
-            });
-        });
-    });
+               // wait for the client to stop processing the response
+               return aliceTestClient.client.downloadKeys(['@chris:abc']);
+           }).then(() => {
+               return aliceTestClient.client._crypto._deviceList.saveIfDirty();
+           }).then(() => {
+               aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
+                   const bobStat = data.trackingStatus['@bob:xyz'];
+                   const chrisStat = data.trackingStatus['@bob:xyz'];

-    // https://github.com/vector-im/element-web/issues/4983
+                   expect(bobStat).toEqual(3);
+                   expect(chrisStat).toEqual(3);
+                   expect(data.syncToken).toEqual(3);
+               });
+           });
+       }).timeout(3000);
+
+    // https://github.com/vector-im/riot-web/issues/4983
    describe("Alice should know she has stale device lists", () => {
        beforeEach(async function() {
            await aliceTestClient.start();
@@ -285,14 +289,13 @@ describe("DeviceList management:", function() {
                },
            );
            await aliceTestClient.httpBackend.flush('/keys/query', 1);
-            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
+            await aliceTestClient.client._crypto._deviceList.saveIfDirty();

-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
+            aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                const bobStat = data.trackingStatus['@bob:xyz'];

-                // Alice should be tracking bob's device list
                expect(bobStat).toBeGreaterThan(
-                    0,
+                    0, "Alice should be tracking bob's device list",
                );
            });
        });
@@ -321,15 +324,15 @@ describe("DeviceList management:", function() {
                },
            );

-            await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto.deviceList.saveIfDirty();

-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
+            await aliceTestClient.flushSync();
+            await aliceTestClient.client._crypto._deviceList.saveIfDirty();
+
+            aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                const bobStat = data.trackingStatus['@bob:xyz'];

-                // Alice should have marked bob's device list as untracked
                expect(bobStat).toEqual(
-                    0,
+                    0, "Alice should have marked bob's device list as untracked",
                );
            });
        });
@@ -359,14 +362,13 @@ describe("DeviceList management:", function() {
            );

            await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
+            await aliceTestClient.client._crypto._deviceList.saveIfDirty();

-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
+            aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                const bobStat = data.trackingStatus['@bob:xyz'];

-                // Alice should have marked bob's device list as untracked
                expect(bobStat).toEqual(
-                    0,
+                    0, "Alice should have marked bob's device list as untracked",
                );
            });
        });
@@ -381,15 +383,13 @@ describe("DeviceList management:", function() {
                anotherTestClient.httpBackend.when('GET', '/sync').respond(
                    200, getSyncResponse([]));
                await anotherTestClient.flushSync();
-                await anotherTestClient.client?.crypto?.deviceList?.saveIfDirty();
+                await anotherTestClient.client._crypto._deviceList.saveIfDirty();

-                // @ts-ignore accessing private property
-                anotherTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus['@bob:xyz'];
+                anotherTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
+                    const bobStat = data.trackingStatus['@bob:xyz'];

-                    // Alice should have marked bob's device list as untracked
                    expect(bobStat).toEqual(
-                        0,
+                        0, "Alice should have marked bob's device list as untracked",
                    );
                });
            } finally {
@@ -0,0 +1,755 @@
+/*
+Copyright 2016 OpenMarket Ltd
+Copyright 2017 Vector Creations Ltd
+Copyright 2018 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.
+*/
+
+/* 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(() => {
+        return aliTestClient.client._crypto._deviceList.saveIfDirty();
+    }).then(() => {
+        aliTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
+            const devices = data.devices[bobUserId];
+            expect(devices[bobDeviceId].keys).toEqual(bobTestClient.deviceKeys.keys);
+            expect(devices[bobDeviceId].verified).
+                toBe(0); // DeviceVerification.UNVERIFIED
+        });
+    });
+}
+
+function aliEnablesEncryption() {
+    return aliTestClient.client.setRoomEncryption(roomId, {
+        algorithm: "m.olm.v1.curve25519-aes-sha2",
+    }).then(function() {
+        expect(aliTestClient.client.isRoomEncrypted(roomId)).toBeTruthy();
+    });
+}
+
+function bobEnablesEncryption() {
+    return bobTestClient.client.setRoomEncryption(roomId, {
+        algorithm: "m.olm.v1.curve25519-aes-sha2",
+    }).then(function() {
+       expect(bobTestClient.client.isRoomEncrypted(roomId)).toBeTruthy();
+    });
+}
+
+/**
+ * Ali sends a message, first claiming e2e keys. Set the expectations and
+ * check the results.
+ *
+ * @return {promise} which resolves to the ciphertext for Bob's device.
+ */
+function aliSendsFirstMessage() {
+    return Promise.all([
+        sendMessage(aliTestClient.client),
+        expectAliQueryKeys()
+            .then(expectAliClaimKeys)
+            .then(expectAliSendMessageRequest),
+    ]).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.httpBackend.verifyNoOutstandingExpectation();
+        bobTestClient.httpBackend.verifyNoOutstandingExpectation();
+
+        return Promise.all([aliTestClient.stop(), bobTestClient.stop()]);
+    });
+
+    it("Bob uploads device keys", function() {
+        return Promise.resolve()
+            .then(bobUploadsDeviceKeys);
+    });
+
+    it("Ali downloads Bobs device keys", function(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());
+    });
+});
@@ -1,682 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-Copyright 2017 Vector Creations Ltd
-Copyright 2018 New Vector Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/* This file consists of a set of integration tests which try to simulate
- * communication via an Olm-encrypted room between two users, Alice and Bob.
- *
- * Note that megolm (group) conversation is not tested here.
- *
- * See also `megolm.spec.js`.
- */
-
-// load olm before the sdk if possible
-import '../olm-loader';
-
-import { logger } from '../../src/logger';
-import * as testUtils from "../test-utils/test-utils";
-import { TestClient } from "../TestClient";
-import { CRYPTO_ENABLED, 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[];
-
-// IMessage isn't exported by src/crypto/algorithms/olm.ts
-interface OlmPayload {
-    type: number;
-    body: string;
-}
-
-async function bobUploadsDeviceKeys(): Promise<void> {
-    bobTestClient.expectDeviceKeyUpload();
-    await Promise.all([
-        bobTestClient.client.uploadKeys(),
-        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.
- *
- * @return {promise} 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 = {};
-    uploaderKeys[uploader.deviceId!] = uploader.deviceKeys;
-    querier.httpBackend.when("POST", "/keys/query")
-        .respond(200, function(_path, content: IUploadKeysRequest) {
-            expect(content.device_keys![uploader.userId!]).toEqual([]);
-            const result = {};
-            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.
- *
- * @return {promise} 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: IUploadKeysRequest) {
-        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 = {};
-        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.
- *
- * @return {promise} 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.
- *
- * @return {promise} 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.
- *
- * @return {promise} 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
- *
- * @return {promise} 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
- *
- * @return {promise} 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: {
-
-            },
-        },
-    };
-    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<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).
- *
- * @param {TestClient} testClient
- * @returns {Promise} 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: { },
-        },
-    };
-    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", () => {
-    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("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 = {};
-        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 = {};
-        bobKeys[bobDeviceId] = bobDeviceKeys;
-        aliTestClient.httpBackend.when(
-            "POST", "/keys/query",
-        ).respond(200, { device_keys: { [bobUserId]: bobKeys } });
-
-        await Promise.all([
-            aliTestClient.client.downloadKeys([bobUserId]),
-            aliTestClient.httpBackend.flush("/keys/query", 1),
-        ]);
-        const devices = aliTestClient.client.getStoredDevicesForUser(bobUserId);
-        // should get an empty list
-        expect(devices).toEqual([]);
-    });
-
-    it("Bob starts his client and uploads device keys and one-time keys", async () => {
-        await bobTestClient.start();
-        const keys = await bobTestClient.awaitOneTimeKeyUpload();
-        expect(Object.keys(keys).length).toEqual(5);
-        expect(Object.keys(bobTestClient.deviceKeys!).length).not.toEqual(0);
-    });
-
-    it("Ali sends a message", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-    });
-
-    it("Bob receives a message", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        bobTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve({});
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-        await bobRecvMessage();
-    });
-
-    it("Bob receives a message with a bogus sender", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        bobTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve({});
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-        const message = aliMessages.shift()!;
-        const syncData = {
-            next_batch: "x",
-            rooms: {
-                join: {
-
-                },
-            },
-        };
-        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<MatrixEvent>((resolve) => {
-            const onEvent = function(event: MatrixEvent) {
-                logger.log(bobUserId + " received event", event);
-                resolve(event);
-            };
-            bobTestClient.client.once(ClientEvent.Event, onEvent);
-        });
-        await bobTestClient.httpBackend.flushAllExpected();
-        const preDecryptionEvent = await eventPromise;
-        expect(preDecryptionEvent.isEncrypted()).toBeTruthy();
-        // it may still be being decrypted
-        const event = await testUtils.awaitDecryption(preDecryptionEvent);
-        expect(event.getType()).toEqual("m.room.message");
-        expect(event.getContent().msgtype).toEqual("m.bad.encrypted");
-    });
-
-    it("Ali blocks Bob's device", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliDownloadsKeys();
-        aliTestClient.client.setDeviceBlocked(bobUserId, bobDeviceId, true);
-        const p1 = sendMessage(aliTestClient.client);
-        const p2 = expectSendMessageRequest(aliTestClient.httpBackend)
-            .then(function(sentContent) {
-                // no unblocked devices, so the ciphertext should be empty
-                expect(sentContent.ciphertext).toEqual({});
-            });
-        await Promise.all([p1, p2]);
-    });
-
-    it("Bob receives two pre-key messages", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        bobTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve({});
-        await firstSync(aliTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-        await bobRecvMessage();
-        await aliSendsMessage();
-        await bobRecvMessage();
-    });
-
-    it("Bob replies to the message", async () => {
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        bobTestClient.expectKeyQuery({ device_keys: { [bobUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await bobTestClient.start();
-        await firstSync(aliTestClient);
-        await firstSync(bobTestClient);
-        await aliEnablesEncryption();
-        await aliSendsFirstMessage();
-        bobTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, {},
-        );
-        await bobRecvMessage();
-        await bobEnablesEncryption();
-        const ciphertext = await bobSendsReplyMessage();
-        expect(ciphertext.type).toEqual(1);
-        await aliRecvMessage();
-    });
-
-    it("Ali does a key query when encryption is enabled", async () => {
-        // enabling encryption in the room should make alice download devices
-        // for both members.
-        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} }, failures: {} });
-        await aliTestClient.start();
-        await firstSync(aliTestClient);
-        const syncData = {
-            next_batch: '2',
-            rooms: {
-                join: {},
-            },
-        };
-        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);
-        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();
-    });
-});
@@ -0,0 +1,321 @@
+"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();
+        return httpBackend.stop();
+    });
+
+    describe("emissions", function() {
+        const SYNC_DATA = {
+            next_batch: "s_5_3",
+            presence: {
+                events: [
+                    utils.mkPresence({
+                        user: "@foo:bar", name: "Foo Bar", presence: "online",
+                    }),
+                ],
+            },
+            rooms: {
+                join: {
+                    "!erufh:bar": {
+                        timeline: {
+                            events: [
+                                utils.mkMessage({
+                                    room: "!erufh:bar", user: "@foo:bar", msg: "hmmm",
+                                }),
+                            ],
+                            prev_batch: "s",
+                        },
+                        state: {
+                            events: [
+                                utils.mkMembership({
+                                    room: "!erufh:bar", mship: "join", user: "@foo:bar",
+                                }),
+                                utils.mkEvent({
+                                    type: "m.room.create", room: "!erufh:bar",
+                                    user: "@foo:bar",
+                                    content: {
+                                        creator: "@foo:bar",
+                                    },
+                                }),
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+        const NEXT_SYNC_DATA = {
+            next_batch: "e_6_7",
+            rooms: {
+                join: {
+                    "!erufh:bar": {
+                        timeline: {
+                            events: [
+                                utils.mkMessage({
+                                    room: "!erufh:bar", user: "@foo:bar",
+                                    msg: "ello ello",
+                                }),
+                                utils.mkMessage({
+                                    room: "!erufh:bar", user: "@foo:bar", msg: ":D",
+                                }),
+                            ],
+                        },
+                        ephemeral: {
+                            events: [
+                                utils.mkEvent({
+                                    type: "m.typing", room: "!erufh:bar", content: {
+                                        user_ids: ["@foo:bar"],
+                                    },
+                                }),
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+
+        it("should emit events from both the first and subsequent /sync calls",
+        function() {
+            httpBackend.when("GET", "/sync").respond(200, SYNC_DATA);
+            httpBackend.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+
+            let expectedEvents = [];
+            expectedEvents = expectedEvents.concat(
+                SYNC_DATA.presence.events,
+                SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
+                SYNC_DATA.rooms.join["!erufh:bar"].state.events,
+                NEXT_SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
+                NEXT_SYNC_DATA.rooms.join["!erufh:bar"].ephemeral.events,
+            );
+
+            client.on("event", function(event) {
+                let found = false;
+                for (let i = 0; i < expectedEvents.length; i++) {
+                    if (expectedEvents[i].event_id === event.getId()) {
+                        expectedEvents.splice(i, 1);
+                        found = true;
+                        break;
+                    }
+                }
+                expect(found).toBe(
+                    true, "Unexpected 'event' emitted: " + event.getType(),
+                );
+            });
+
+            client.startClient();
+
+            return Promise.all([
+                // wait for two SYNCING events
+                utils.syncPromise(client).then(() => {
+                    return utils.syncPromise(client);
+                }),
+                httpBackend.flushAllExpected(),
+            ]).then(() => {
+                expect(expectedEvents.length).toEqual(
+                    0, "Failed to see all events from /sync calls",
+                );
+            });
+        });
+
+        it("should emit User events", function(done) {
+            httpBackend.when("GET", "/sync").respond(200, SYNC_DATA);
+            httpBackend.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+            let fired = false;
+            client.on("User.presence", function(event, user) {
+                fired = true;
+                expect(user).toBeTruthy();
+                expect(event).toBeTruthy();
+                if (!user || !event) {
+                    return;
+                }
+
+                expect(event.event).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,335 +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: {
-                                        creator: "@foo:bar",
-                                    },
-                                }),
-                            ],
-                        },
-                    },
-                },
-            },
-        };
-        const NEXT_SYNC_DATA = {
-            next_batch: "e_6_7",
-            rooms: {
-                join: {
-                    "!erufh:bar": {
-                        timeline: {
-                            events: [
-                                utils.mkMessage({
-                                    room: "!erufh:bar", user: "@foo:bar",
-                                    msg: "ello ello",
-                                }),
-                                utils.mkMessage({
-                                    room: "!erufh:bar", user: "@foo:bar", msg: ":D",
-                                }),
-                            ],
-                        },
-                        ephemeral: {
-                            events: [
-                                utils.mkEvent({
-                                    type: "m.typing", room: "!erufh:bar", content: {
-                                        user_ids: ["@foo:bar"],
-                                    },
-                                }),
-                            ],
-                        },
-                    },
-                },
-            },
-        };
-
-        it("should emit events from both the first and subsequent /sync calls",
-            function() {
-                httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-                httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-
-                let expectedEvents: Partial<IEvent>[] = [];
-                expectedEvents = expectedEvents.concat(
-                    SYNC_DATA.presence.events,
-                    SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
-                    SYNC_DATA.rooms.join["!erufh:bar"].state.events,
-                    NEXT_SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
-                    NEXT_SYNC_DATA.rooms.join["!erufh:bar"].ephemeral.events,
-                );
-
-                client!.on(ClientEvent.Event, function(event) {
-                    let found = false;
-                    for (let i = 0; i < expectedEvents.length; i++) {
-                        if (expectedEvents[i].event_id === event.getId()) {
-                            expectedEvents.splice(i, 1);
-                            found = true;
-                            break;
-                        }
-                    }
-                    expect(found).toBe(true);
-                });
-
-                client!.startClient();
-
-                return Promise.all([
-                // wait for two SYNCING events
-                    utils.syncPromise(client!).then(() => {
-                        return utils.syncPromise(client!);
-                    }),
-                    httpBackend!.flushAllExpected(),
-                ]).then(() => {
-                    expect(expectedEvents.length).toEqual(0);
-                });
-            });
-
-        it("should emit User events", function(done) {
-            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-            let fired = false;
-            client!.on(UserEvent.Presence, function(event, user) {
-                fired = true;
-                expect(user).toBeTruthy();
-                expect(event).toBeTruthy();
-                if (!user || !event) {
-                    return;
-                }
-
-                expect(event.event).toEqual(SYNC_DATA.presence.events[0]);
-                expect(user.presence).toEqual(
-                    SYNC_DATA.presence.events[0]?.content?.presence,
-                );
-            });
-            client!.startClient();
-
-            httpBackend!.flushAllExpected().then(function() {
-                expect(fired).toBe(true);
-                done();
-            });
-        });
-
-        it("should emit Room events", function() {
-            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-            let roomInvokeCount = 0;
-            let roomNameInvokeCount = 0;
-            let timelineFireCount = 0;
-            client!.on(ClientEvent.Room, function(room) {
-                roomInvokeCount++;
-                expect(room.roomId).toEqual("!erufh:bar");
-            });
-            client!.on(RoomEvent.Timeline, function(event, room) {
-                timelineFireCount++;
-                expect(room?.roomId).toEqual("!erufh:bar");
-            });
-            client!.on(RoomEvent.Name, function(room) {
-                roomNameInvokeCount++;
-            });
-
-            client!.startClient();
-
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                utils.syncPromise(client!, 2),
-            ]).then(function() {
-                expect(roomInvokeCount).toEqual(1);
-                expect(roomNameInvokeCount).toEqual(1);
-                expect(timelineFireCount).toEqual(3);
-            });
-        });
-
-        it("should emit RoomState events", function() {
-            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-
-            const roomStateEventTypes = [
-                "m.room.member", "m.room.create",
-            ];
-            let eventsInvokeCount = 0;
-            let membersInvokeCount = 0;
-            let newMemberInvokeCount = 0;
-            client!.on(RoomStateEvent.Events, function(event, state) {
-                eventsInvokeCount++;
-                const index = roomStateEventTypes.indexOf(event.getType());
-                expect(index).not.toEqual(-1);
-                if (index >= 0) {
-                    roomStateEventTypes.splice(index, 1);
-                }
-            });
-            client!.on(RoomStateEvent.Members, function(event, state, member) {
-                membersInvokeCount++;
-                expect(member.roomId).toEqual("!erufh:bar");
-                expect(member.userId).toEqual("@foo:bar");
-                expect(member.membership).toEqual("join");
-            });
-            client!.on(RoomStateEvent.NewMember, function(event, state, member) {
-                newMemberInvokeCount++;
-                expect(member.roomId).toEqual("!erufh:bar");
-                expect(member.userId).toEqual("@foo:bar");
-                expect(member.membership).toBeFalsy();
-            });
-
-            client!.startClient();
-
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                utils.syncPromise(client!, 2),
-            ]).then(function() {
-                expect(membersInvokeCount).toEqual(1);
-                expect(newMemberInvokeCount).toEqual(1);
-                expect(eventsInvokeCount).toEqual(2);
-            });
-        });
-
-        it("should emit RoomMember events", function() {
-            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-
-            let typingInvokeCount = 0;
-            let powerLevelInvokeCount = 0;
-            let nameInvokeCount = 0;
-            let membershipInvokeCount = 0;
-            client!.on(RoomMemberEvent.Name, function(event, member) {
-                nameInvokeCount++;
-            });
-            client!.on(RoomMemberEvent.Typing, function(event, member) {
-                typingInvokeCount++;
-                expect(member.typing).toBe(true);
-            });
-            client!.on(RoomMemberEvent.PowerLevel, function(event, member) {
-                powerLevelInvokeCount++;
-            });
-            client!.on(RoomMemberEvent.Membership, function(event, member) {
-                membershipInvokeCount++;
-                expect(member.membership).toEqual("join");
-            });
-
-            client!.startClient();
-
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                utils.syncPromise(client!, 2),
-            ]).then(function() {
-                expect(typingInvokeCount).toEqual(1);
-                expect(powerLevelInvokeCount).toEqual(0);
-                expect(nameInvokeCount).toEqual(0);
-                expect(membershipInvokeCount).toEqual(1);
-            });
-        });
-
-        it("should emit Session.logged_out on M_UNKNOWN_TOKEN", function() {
-            const error = { errcode: 'M_UNKNOWN_TOKEN' };
-            httpBackend!.when("GET", "/sync").respond(401, error);
-
-            let sessionLoggedOutCount = 0;
-            client!.on(HttpApiEvent.SessionLoggedOut, function(errObj) {
-                sessionLoggedOutCount++;
-                expect(errObj.data).toEqual(error);
-            });
-
-            client!.startClient();
-
-            return httpBackend!.flushAllExpected().then(function() {
-                expect(sessionLoggedOutCount).toEqual(1);
-            });
-        });
-
-        it("should emit Session.logged_out on M_UNKNOWN_TOKEN (soft logout)", function() {
-            const error = { errcode: 'M_UNKNOWN_TOKEN', soft_logout: true };
-            httpBackend!.when("GET", "/sync").respond(401, error);
-
-            let sessionLoggedOutCount = 0;
-            client!.on(HttpApiEvent.SessionLoggedOut, function(errObj) {
-                sessionLoggedOutCount++;
-                expect(errObj.data).toEqual(error);
-            });
-
-            client!.startClient();
-
-            return httpBackend!.flushAllExpected().then(function() {
-                expect(sessionLoggedOutCount).toEqual(1);
-            });
-        });
-    });
-});
@@ -0,0 +1,769 @@
+"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();
+        }
+        return httpBackend.stop();
+    });
+
+    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,419 @@
+"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();
+        return httpBackend.stop();
+    });
+
+    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, userId);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userId, room: roomId, mship: "join", event: true,
+                }),
+            ]);
+            store.storeRoom(room);
+            client.joinRoom(roomId);
+            httpBackend.verifyNoOutstandingRequests();
+        });
+    });
+
+    describe("getFilter", function() {
+        const filterId = "f1lt3r1d";
+
+        it("should return a filter from the store if allowCached", function(done) {
+            const filter = Filter.fromJson(userId, filterId, {
+                event_format: "client",
+            });
+            store.storeFilter(filter);
+            client.getFilter(userId, filterId, true).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]);
+        }
+    }
+}
@@ -1,15 +1,17 @@
-import HttpBackend from "matrix-mock-request";
+"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 * as utils from "../test-utils/test-utils";
-import { MatrixClient } from "../../src/matrix";
-import { MatrixScheduler } from "../../src/scheduler";
-import { MemoryStore } from "../../src/store/memory";
-import { MatrixError } from "../../src/http-api";
-import { IStore } from "../../src/store";
+import expect from 'expect';
+import Promise from 'bluebird';

 describe("MatrixClient opts", function() {
    const baseUrl = "http://localhost.or.something";
-    let httpBackend = new HttpBackend();
+    let client = null;
+    let httpBackend = null;
    const userId = "@alice:localhost";
    const userB = "@bob:localhost";
    const accessToken = "aseukfgwef";
@@ -56,6 +58,7 @@ describe("MatrixClient opts", function() {
    };

    beforeEach(function() {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
        httpBackend = new HttpBackend();
    });

@@ -65,15 +68,14 @@ describe("MatrixClient opts", function() {
    });

    describe("without opts.store", function() {
-        let client;
        beforeEach(function() {
            client = new MatrixClient({
-                fetchFn: httpBackend.fetchFn as typeof global.fetch,
+                request: httpBackend.requestFn,
                store: undefined,
                baseUrl: baseUrl,
                userId: userId,
                accessToken: accessToken,
-                scheduler: new MatrixScheduler(),
+                scheduler: new sdk.MatrixScheduler(),
            });
        });

@@ -86,7 +88,7 @@ describe("MatrixClient opts", function() {
            httpBackend.when("PUT", "/txn1").respond(200, {
                event_id: eventId,
            });
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
+            client.sendTextMessage("!foo:bar", "a body", "txn1").done(function(res) {
                expect(res.event_id).toEqual(eventId);
                done();
            });
@@ -99,19 +101,17 @@ describe("MatrixClient opts", function() {
                "m.room.create",
            ];
            client.on("event", function(event) {
-                expect(expectedEventTypes.indexOf(event.getType())).not.toEqual(
-                    -1,
+                expect(expectedEventTypes.indexOf(event.getType())).toNotEqual(
+                    -1, "Recv unexpected event type: " + event.getType(),
                );
                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 client.startClient();
            await httpBackend.flush("/pushrules", 1);
            await httpBackend.flush("/filter", 1);
            await Promise.all([
@@ -119,17 +119,16 @@ describe("MatrixClient opts", function() {
                utils.syncPromise(client),
            ]);
            expect(expectedEventTypes.length).toEqual(
-                0,
+                0, "Expected to see event types: " + expectedEventTypes,
            );
        });
    });

    describe("without opts.scheduler", function() {
-        let client;
        beforeEach(function() {
            client = new MatrixClient({
-                fetchFn: httpBackend.fetchFn as typeof global.fetch,
-                store: new MemoryStore() as IStore,
+                request: httpBackend.requestFn,
+                store: new sdk.MatrixInMemoryStore(),
                baseUrl: baseUrl,
                userId: userId,
                accessToken: accessToken,
@@ -137,17 +136,13 @@ describe("MatrixClient opts", function() {
            });
        });

-        afterEach(function() {
-            client.stopClient();
-        });
-
        it("shouldn't retry sending events", function(done) {
-            httpBackend.when("PUT", "/txn1").respond(500, new MatrixError({
+            httpBackend.when("PUT", "/txn1").fail(500, {
                errcode: "M_SOMETHING",
                error: "Ruh roh",
-            }));
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
-                expect(false).toBe(true);
+            });
+            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();
@@ -164,16 +159,16 @@ describe("MatrixClient opts", function() {
            });
            let sentA = false;
            let sentB = false;
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
+            client.sendTextMessage("!foo:bar", "a body", "txn1").done(function(res) {
                sentA = true;
                expect(sentB).toBe(true);
            });
-            client.sendTextMessage("!foo:bar", "b body", "txn2").then(function(res) {
+            client.sendTextMessage("!foo:bar", "b body", "txn2").done(function(res) {
                sentB = true;
                expect(sentA).toBe(false);
            });
-            httpBackend.flush("/txn2", 1).then(function() {
-                httpBackend.flush("/txn1", 1).then(function() {
+            httpBackend.flush("/txn2", 1).done(function() {
+                httpBackend.flush("/txn1", 1).done(function() {
                    done();
                });
            });
@@ -183,7 +178,7 @@ describe("MatrixClient opts", function() {
            httpBackend.when("PUT", "/txn1").respond(200, {
                event_id: "foo",
            });
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
+            client.sendTextMessage("!foo:bar", "a body", "txn1").done(function(res) {
                expect(res.event_id).toEqual("foo");
                done();
            });
@@ -1,127 +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/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/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/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/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" });
-    });
-});
@@ -1,57 +1,42 @@
-/*
-Copyright 2022 The Matrix.org Foundation C.I.C.
+"use strict";
+import 'source-map-support/register';
+import Promise from 'bluebird';

-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
+const sdk = require("../..");
+const HttpBackend = require("matrix-mock-request");
+const utils = require("../test-utils");
+const EventStatus = sdk.EventStatus;

-    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";
+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 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];
-    };
+    let room;

    beforeEach(function() {
-        [client, httpBackend, room] = setupTests();
+        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();
-        return httpBackend!.stop();
+        httpBackend.verifyNoOutstandingExpectation();
+        return httpBackend.stop();
    });

    xit("should retry according to MatrixScheduler.retryFn", function() {
@@ -72,26 +57,20 @@ describe("MatrixClient retrying", 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() {
+        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, {
-            "msgtype": "m.text",
-            "body": "m2",
-        });
+        client.sendMessage(roomId, "m2");

        // both events should be in the timeline at this point
-        const tl = room!.getLiveTimeline().getEvents();
+        const tl = room.getLiveTimeline().getEvents();
        expect(tl.length).toEqual(2);
        const ev1 = tl[0];
        const ev2 = tl[1];
@@ -100,25 +79,25 @@ describe("MatrixClient retrying", function() {
        expect(ev2.status).toEqual(EventStatus.SENDING);

        // the first message should get sent, and the second should get queued
-        httpBackend!.when("PUT", "/send/m.room.message/").check(function() {
+        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);
+            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);
+                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) {
+        const p3 = new Promise((resolve, reject) => {
+            room.on("Room.localEchoUpdated", (ev0) => {
+                if(ev0 === ev1) {
                    resolve();
                }
            });
@@ -127,7 +106,7 @@ describe("MatrixClient retrying", function() {
            expect(tl.length).toEqual(1);

            // cancel the first message
-            client!.cancelPendingEvent(ev1);
+            client.cancelPendingEvent(ev1);
            expect(ev1.status).toEqual(EventStatus.CANCELLED);
            expect(tl.length).toEqual(0);
        });
@@ -135,7 +114,7 @@ describe("MatrixClient retrying", function() {
        return Promise.all([
            p1,
            p3,
-            httpBackend!.flushAllExpected(),
+            httpBackend.flushAllExpected(),
        ]);
    });

@@ -0,0 +1,614 @@
+"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();
+        return httpBackend.stop();
+    });
+
+    describe("local echo events", function() {
+        it("should be added immediately after calling MatrixClient.sendEvent " +
+        "with EventStatus.SENDING and the right event.sender", function(done) {
+            client.on("sync", function(state) {
+                if (state !== "PREPARED") {
+                    return;
+                }
+                const room = client.getRoom(roomId);
+                expect(room.timeline.length).toEqual(1);
+
+                client.sendTextMessage(roomId, "I am a fish", "txn1");
+                // check it was added
+                expect(room.timeline.length).toEqual(2);
+                // check status
+                expect(room.timeline[1].status).toEqual(EventStatus.SENDING);
+                // check member
+                const member = room.timeline[1].sender;
+                expect(member.userId).toEqual(userId);
+                expect(member.name).toEqual(userName);
+
+                httpBackend.flush("/sync", 1).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,884 +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 } 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;
-    const SYNC_DATA = {
-        next_batch: "s_5_3",
-        rooms: {
-            join: {
-                "!foo:bar": { // roomId
-                    timeline: {
-                        events: [
-                            utils.mkMessage({
-                                room: roomId, user: otherUserId, msg: "hello",
-                            }),
-                        ],
-                        prev_batch: "f_1_1",
-                    },
-                    state: {
-                        events: [
-                            ROOM_NAME_EVENT,
-                            utils.mkMembership({
-                                room: roomId, mship: "join",
-                                user: otherUserId, name: "Bob",
-                            }),
-                            USER_MEMBERSHIP_EVENT,
-                            utils.mkEvent({
-                                type: "m.room.create", room: roomId, user: userId,
-                                content: {
-                                    creator: userId,
-                                },
-                            }),
-                        ],
-                    },
-                },
-            },
-        },
-    };
-
-    function setNextSyncData(events: Partial<IEvent>[] = []) {
-        NEXT_SYNC_DATA = {
-            next_batch: "n",
-            presence: { events: [] },
-            rooms: {
-                invite: {},
-                join: {
-                    "!foo:bar": {
-                        timeline: { events: [] },
-                        state: { events: [] },
-                        ephemeral: { events: [] },
-                    },
-                },
-                leave: {},
-            },
-        };
-        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);
-            } 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);
-            }
-        });
-    }
-
-    const setupTestClient = (): [MatrixClient, HttpBackend] => {
-        // these tests should work with or without timelineSupport
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { timelineSupport: true },
-        );
-        const httpBackend = testClient.httpBackend;
-        const client = testClient.client;
-
-        setNextSyncData();
-        httpBackend!.when("GET", "/versions").respond(200, {});
-        httpBackend!.when("GET", "/pushrules").respond(200, {});
-        httpBackend!.when("POST", "/filter").respond(200, { filter_id: "fid" });
-        httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-        httpBackend!.when("GET", "/sync").respond(200, function() {
-            return NEXT_SYNC_DATA;
-        });
-        client!.startClient();
-
-        return [client!, httpBackend];
-    };
-
-    beforeEach(async function() {
-        [client!, httpBackend] = setupTestClient();
-        await httpBackend.flush("/versions");
-        await httpBackend.flush("/pushrules");
-        await httpBackend.flush("/filter");
-    });
-
-    afterEach(function() {
-        httpBackend!.verifyNoOutstandingExpectation();
-        client!.stopClient();
-        return httpBackend!.stop();
-    });
-
-    describe("local echo events", function() {
-        it("should be added immediately after calling MatrixClient.sendEvent " +
-        "with EventStatus.SENDING and the right event.sender", function(done) {
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                expect(room.timeline.length).toEqual(1);
-
-                client!.sendTextMessage(roomId, "I am a fish", "txn1");
-                // check it was added
-                expect(room.timeline.length).toEqual(2);
-                // check status
-                expect(room.timeline[1].status).toEqual(EventStatus.SENDING);
-                // check member
-                const member = room.timeline[1].sender;
-                expect(member?.userId).toEqual(userId);
-                expect(member?.name).toEqual(userName);
-
-                httpBackend!.flush("/sync", 1).then(function() {
-                    done();
-                });
-            });
-            httpBackend!.flush("/sync", 1);
-        });
-
-        it("should be updated correctly when the send request finishes " +
-        "BEFORE the event comes down the event stream", function(done) {
-            const eventId = "$foo:bar";
-            httpBackend!.when("PUT", "/txn1").respond(200, {
-                event_id: eventId,
-            });
-
-            const ev = utils.mkMessage({
-                msg: "I am a fish", user: userId, room: roomId,
-            });
-            ev.event_id = eventId;
-            ev.unsigned = { transaction_id: "txn1" };
-            setNextSyncData([ev]);
-
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                client!.sendTextMessage(roomId, "I am a fish", "txn1").then(
-                    function() {
-                        expect(room.timeline[1].getId()).toEqual(eventId);
-                        httpBackend!.flush("/sync", 1).then(function() {
-                            expect(room.timeline[1].getId()).toEqual(eventId);
-                            done();
-                        });
-                    });
-                httpBackend!.flush("/txn1", 1);
-            });
-            httpBackend!.flush("/sync", 1);
-        });
-
-        it("should be updated correctly when the send request finishes " +
-        "AFTER the event comes down the event stream", function(done) {
-            const eventId = "$foo:bar";
-            httpBackend!.when("PUT", "/txn1").respond(200, {
-                event_id: eventId,
-            });
-
-            const ev = utils.mkMessage({
-                msg: "I am a fish", user: userId, room: roomId,
-            });
-            ev.event_id = eventId;
-            ev.unsigned = { transaction_id: "txn1" };
-            setNextSyncData([ev]);
-
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                const promise = client!.sendTextMessage(roomId, "I am a fish", "txn1");
-                httpBackend!.flush("/sync", 1).then(function() {
-                    expect(room.timeline.length).toEqual(2);
-                    httpBackend!.flush("/txn1", 1);
-                    promise.then(function() {
-                        expect(room.timeline.length).toEqual(2);
-                        expect(room.timeline[1].getId()).toEqual(eventId);
-                        done();
-                    });
-                });
-            });
-            httpBackend!.flush("/sync", 1);
-        });
-    });
-
-    describe("paginated events", function() {
-        let sbEvents;
-        const sbEndTok = "pagin_end";
-
-        beforeEach(function() {
-            sbEvents = [];
-            httpBackend!.when("GET", "/messages").respond(200, function() {
-                return {
-                    chunk: sbEvents,
-                    start: "pagin_start",
-                    end: sbEndTok,
-                };
-            });
-        });
-
-        it("should set Room.oldState.paginationToken to null at the start" +
-        " of the timeline.", function(done) {
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                expect(room.timeline.length).toEqual(1);
-
-                client!.scrollback(room).then(function() {
-                    expect(room.timeline.length).toEqual(1);
-                    expect(room.oldState.paginationToken).toBe(null);
-
-                    // still have a sync to flush
-                    httpBackend!.flush("/sync", 1).then(() => {
-                        done();
-                    });
-                });
-
-                httpBackend!.flush("/messages", 1);
-            });
-            httpBackend!.flush("/sync", 1);
-        });
-
-        it("should set the right event.sender values", function(done) {
-            // We're aiming for an eventual timeline of:
-            //
-            // 'Old Alice' joined the room
-            // <Old Alice> I'm old alice
-            // @alice:localhost changed their name from 'Old Alice' to 'Alice'
-            // <Alice> I'm alice
-            // ------^ /messages results above this point, /sync result below
-            // <Bob> hello
-
-            // make an m.room.member event for alice's join
-            const joinMshipEvent = utils.mkMembership({
-                mship: "join", user: userId, room: roomId, name: "Old Alice",
-                url: undefined,
-            });
-
-            // make an m.room.member event with prev_content for alice's nick
-            // change
-            const oldMshipEvent = utils.mkMembership({
-                mship: "join", user: userId, room: roomId, name: userName,
-                url: "mxc://some/url",
-            });
-            oldMshipEvent.prev_content = {
-                displayname: "Old Alice",
-                avatar_url: undefined,
-                membership: "join",
-            };
-
-            // set the list of events to return on scrollback (/messages)
-            // N.B. synapse returns /messages in reverse chronological order
-            sbEvents = [
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I'm alice",
-                }),
-                oldMshipEvent,
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I'm old alice",
-                }),
-                joinMshipEvent,
-            ];
-
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                // sync response
-                expect(room.timeline.length).toEqual(1);
-
-                client!.scrollback(room).then(function() {
-                    expect(room.timeline.length).toEqual(5);
-                    const joinMsg = room.timeline[0];
-                    expect(joinMsg.sender?.name).toEqual("Old Alice");
-                    const oldMsg = room.timeline[1];
-                    expect(oldMsg.sender?.name).toEqual("Old Alice");
-                    const newMsg = room.timeline[3];
-                    expect(newMsg.sender?.name).toEqual(userName);
-
-                    // still have a sync to flush
-                    httpBackend!.flush("/sync", 1).then(() => {
-                        done();
-                    });
-                });
-
-                httpBackend!.flush("/messages", 1);
-            });
-            httpBackend!.flush("/sync", 1);
-        });
-
-        it("should add it them to the right place in the timeline", function(done) {
-            // set the list of events to return on scrollback
-            sbEvents = [
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I am new",
-                }),
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I am old",
-                }),
-            ];
-
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                expect(room.timeline.length).toEqual(1);
-
-                client!.scrollback(room).then(function() {
-                    expect(room.timeline.length).toEqual(3);
-                    expect(room.timeline[0].event).toEqual(sbEvents[1]);
-                    expect(room.timeline[1].event).toEqual(sbEvents[0]);
-
-                    // still have a sync to flush
-                    httpBackend!.flush("/sync", 1).then(() => {
-                        done();
-                    });
-                });
-
-                httpBackend!.flush("/messages", 1);
-            });
-            httpBackend!.flush("/sync", 1);
-        });
-
-        it("should use 'end' as the next pagination token", function(done) {
-            // set the list of events to return on scrollback
-            sbEvents = [
-                utils.mkMessage({
-                    user: userId, room: roomId, msg: "I am new",
-                }),
-            ];
-
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                expect(room.oldState.paginationToken).toBeTruthy();
-
-                client!.scrollback(room, 1).then(function() {
-                    expect(room.oldState.paginationToken).toEqual(sbEndTok);
-                });
-
-                httpBackend!.flush("/messages", 1).then(function() {
-                    // still have a sync to flush
-                    httpBackend!.flush("/sync", 1).then(() => {
-                        done();
-                    });
-                });
-            });
-            httpBackend!.flush("/sync", 1);
-        });
-    });
-
-    describe("new events", function() {
-        it("should be added to the right place in the timeline", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(eventData);
-
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
-                const room = client!.getRoom(roomId)!;
-
-                let index = 0;
-                client!.on(RoomEvent.Timeline, function(event, rm, toStart) {
-                    expect(toStart).toBe(false);
-                    expect(rm).toEqual(room);
-                    expect(event.event).toEqual(eventData[index]);
-                    index += 1;
-                });
-
-                httpBackend!.flush("/messages", 1);
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
-                    expect(index).toEqual(2);
-                    expect(room.timeline.length).toEqual(3);
-                    expect(room.timeline[2].event).toEqual(
-                        eventData[1],
-                    );
-                    expect(room.timeline[1].event).toEqual(
-                        eventData[0],
-                    );
-                });
-            });
-        });
-
-        it("should set the right event.sender values", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-                utils.mkMembership({
-                    user: userId, room: roomId, mship: "join", name: "New Name",
-                }),
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(eventData);
-
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
-                const room = client!.getRoom(roomId)!;
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
-                    const preNameEvent = room.timeline[room.timeline.length - 3];
-                    const postNameEvent = room.timeline[room.timeline.length - 1];
-                    expect(preNameEvent.sender?.name).toEqual(userName);
-                    expect(postNameEvent.sender?.name).toEqual("New Name");
-                });
-            });
-        });
-
-        it("should set the right room.name", function() {
-            const secondRoomNameEvent = utils.mkEvent({
-                user: userId, room: roomId, type: "m.room.name", content: {
-                    name: "Room 2",
-                },
-            });
-            setNextSyncData([secondRoomNameEvent]);
-
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
-                const room = client!.getRoom(roomId)!;
-                let nameEmitCount = 0;
-                client!.on(RoomEvent.Name, function(rm) {
-                    nameEmitCount += 1;
-                });
-
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
-                    expect(nameEmitCount).toEqual(1);
-                    expect(room.name).toEqual("Room 2");
-                    // do another round
-                    const thirdRoomNameEvent = utils.mkEvent({
-                        user: userId, room: roomId, type: "m.room.name", content: {
-                            name: "Room 3",
-                        },
-                    });
-                    setNextSyncData([thirdRoomNameEvent]);
-                    httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-                    return Promise.all([
-                        httpBackend!.flush("/sync", 1),
-                        utils.syncPromise(client!),
-                    ]);
-                }).then(function() {
-                    expect(nameEmitCount).toEqual(2);
-                    expect(room.name).toEqual("Room 3");
-                });
-            });
-        });
-
-        it("should set the right room members", function() {
-            const userC = "@cee:bar";
-            const userD = "@dee:bar";
-            const eventData = [
-                utils.mkMembership({
-                    user: userC, room: roomId, mship: "join", name: "C",
-                }),
-                utils.mkMembership({
-                    user: userC, room: roomId, mship: "invite", skey: userD,
-                }),
-            ];
-            setNextSyncData(eventData);
-
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
-                const room = client!.getRoom(roomId)!;
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
-                    expect(room.currentState.getMembers().length).toEqual(4);
-                    expect(room.currentState.getMember(userC)!.name).toEqual("C");
-                    expect(room.currentState.getMember(userC)!.membership).toEqual(
-                        "join",
-                    );
-                    expect(room.currentState.getMember(userD)!.name).toEqual(userD);
-                    expect(room.currentState.getMember(userD)!.membership).toEqual(
-                        "invite",
-                    );
-                });
-            });
-        });
-    });
-
-    describe("gappy sync", function() {
-        it("should copy the last known state to the new timeline", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(eventData);
-            NEXT_SYNC_DATA.rooms.join[roomId].timeline.limited = true;
-
-            return Promise.all([
-                httpBackend!.flush("/versions", 1),
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
-                const room = client!.getRoom(roomId)!;
-
-                httpBackend!.flush("/messages", 1);
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
-                    expect(room.timeline.length).toEqual(1);
-                    expect(room.timeline[0].event).toEqual(eventData[0]);
-                    expect(room.currentState.getMembers().length).toEqual(2);
-                    expect(room.currentState.getMember(userId)!.name).toEqual(userName);
-                    expect(room.currentState.getMember(userId)!.membership).toEqual(
-                        "join",
-                    );
-                    expect(room.currentState.getMember(otherUserId)!.name).toEqual("Bob");
-                    expect(room.currentState.getMember(otherUserId)!.membership).toEqual(
-                        "join",
-                    );
-                });
-            });
-        });
-
-        it("should emit a `RoomEvent.TimelineReset` event when the sync response is `limited`", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
-            setNextSyncData(eventData);
-            NEXT_SYNC_DATA.rooms.join[roomId].timeline.limited = true;
-
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
-                const room = client!.getRoom(roomId)!;
-
-                let emitCount = 0;
-                client!.on(RoomEvent.TimelineReset, function(emitRoom) {
-                    expect(emitRoom).toEqual(room);
-                    emitCount++;
-                });
-
-                httpBackend!.flush("/messages", 1);
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
-                    expect(emitCount).toEqual(1);
-                });
-            });
-        });
-    });
-
-    describe('Refresh live timeline', () => {
-        const initialSyncEventData = [
-            utils.mkMessage({ user: userId, room: roomId }),
-            utils.mkMessage({ user: userId, room: roomId }),
-            utils.mkMessage({ user: userId, room: roomId }),
-        ];
-
-        const contextUrl = `/rooms/${encodeURIComponent(roomId)}/context/` +
-        `${encodeURIComponent(initialSyncEventData[2].event_id!)}`;
-        const contextResponse = {
-            start: "start_token",
-            events_before: [initialSyncEventData[1], initialSyncEventData[0]],
-            event: initialSyncEventData[2],
-            events_after: [],
-            state: [
-                USER_MEMBERSHIP_EVENT,
-            ],
-            end: "end_token",
-        };
-
-        let room;
-        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,768 @@
+"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();
+        return httpBackend.stop();
+    });
+
+    describe("startClient", function() {
+        const syncData = {
+            next_batch: "batch_token",
+            rooms: {},
+            presence: {},
+        };
+
+        it("should /sync after /pushrules and /filter.", function(done) {
+            httpBackend.when("GET", "/sync").respond(200, syncData);
+
+            client.startClient();
+
+            httpBackend.flushAllExpected().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);
+            });
+        });
+
+        // XXX: This test asserts that the js-sdk obeys the spec and treats state
+        // events that arrive in the incremental sync as if they preceeded the
+        // timeline events, however this breaks peeking, so it's disabled
+        // (see sync.js)
+        xit("should correctly interpret state in incremental sync.", function() {
+            httpBackend.when("GET", "/sync").respond(200, syncData);
+            httpBackend.when("GET", "/sync").respond(200, nextSyncData);
+
+            client.startClient();
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                awaitSyncEvent(2),
+            ]).then(function() {
+                const room = client.getRoom(roomOne);
+                const stateAtStart = room.getLiveTimeline().getState(
+                    EventTimeline.BACKWARDS,
+                );
+                const startRoomNameEvent = stateAtStart.getStateEvents('m.room.name', '');
+                expect(startRoomNameEvent.getContent().name).toEqual('Old room name');
+
+                const stateAtEnd = room.getLiveTimeline().getState(
+                    EventTimeline.FORWARDS,
+                );
+                const endRoomNameEvent = stateAtEnd.getStateEvents('m.room.name', '');
+                expect(endRoomNameEvent.getContent().name).toEqual('A new room name');
+            });
+        });
+
+        xit("should update power levels for users in a room", function() {
+
+        });
+
+        xit("should update the room topic", function() {
+
+        });
+    });
+
+    describe("timeline", function() {
+        beforeEach(function() {
+            const syncData = {
+                next_batch: "batch_token",
+                rooms: {
+                    join: {},
+                },
+            };
+            syncData.rooms.join[roomOne] = {
+                timeline: {
+                    events: [
+                        utils.mkMessage({
+                            room: roomOne, user: otherUserId, msg: "hello",
+                        }),
+                    ],
+                    prev_batch: "pagTok",
+                },
+            };
+
+            httpBackend.when("GET", "/sync").respond(200, syncData);
+
+            client.startClient();
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                awaitSyncEvent(),
+            ]);
+        });
+
+        it("should set the back-pagination token on new rooms", function() {
+            const syncData = {
+                next_batch: "batch_token",
+                rooms: {
+                    join: {},
+                },
+            };
+            syncData.rooms.join[roomTwo] = {
+                timeline: {
+                    events: [
+                        utils.mkMessage({
+                            room: roomTwo, user: otherUserId, msg: "roomtwo",
+                        }),
+                    ],
+                    prev_batch: "roomtwotok",
+                },
+            };
+
+            httpBackend.when("GET", "/sync").respond(200, syncData);
+
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                awaitSyncEvent(),
+            ]).then(function() {
+                const room = client.getRoom(roomTwo);
+                expect(room).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,170 +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 { Account } from "@matrix-org/olm";
-
-import { logger } from "../../src/logger";
-import { decodeRecoveryKey } from "../../src/crypto/recoverykey";
-import { IKeyBackupInfo, IKeyBackupSession } from "../../src/crypto/keybackup";
-import { TestClient } from "../TestClient";
-import { IEvent } from "../../src";
-import { MatrixEvent, MatrixEventEvent } from "../../src/models/event";
-
-const ROOM_ID = '!ROOM:ID';
-
-const SESSION_ID = 'o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc';
-
-const ENCRYPTED_EVENT: Partial<IEvent> = {
-    type: 'm.room.encrypted',
-    content: {
-        algorithm: 'm.megolm.v1.aes-sha2',
-        sender_key: 'SENDER_CURVE25519',
-        session_id: SESSION_ID,
-        ciphertext: 'AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N'
-            + 'CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl'
-            + 'mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs',
-    },
-    room_id: '!ROOM:ID',
-    event_id: '$event1',
-    origin_server_ts: 1507753886000,
-};
-
-const CURVE25519_KEY_BACKUP_DATA: IKeyBackupSession = {
-    first_message_index: 0,
-    forwarded_count: 0,
-    is_verified: false,
-    session_data: {
-        ciphertext: '2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw'
-            + '6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ'
-            + 'Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9'
-            + 'SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy'
-            + 'Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF'
-            + 'ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV'
-            + '4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv'
-            + 'C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe'
-            + 'Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf'
-            + 'QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy'
-            + 'iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg',
-        mac: '5lxYBHQU80M',
-        ephemeral: '/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14',
-    },
-};
-
-const CURVE25519_BACKUP_INFO: IKeyBackupInfo = {
-    algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
-    version: "1",
-    auth_data: {
-        public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-    },
-};
-
-const RECOVERY_KEY = "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d";
-
-/**
- * start an Olm session with a given recipient
- */
-function createOlmSession(olmAccount: Olm.Account, recipientTestClient: TestClient): Promise<Olm.Session> {
-    return recipientTestClient.awaitOneTimeKeyUpload().then((keys) => {
-        const otkId = Object.keys(keys)[0];
-        const otk = keys[otkId];
-
-        const session = new global.Olm.Session();
-        session.create_outbound(
-            olmAccount, recipientTestClient.getDeviceKey(), otk.key,
-        );
-        return session;
-    });
-}
-
-describe("megolm key backups", function() {
-    if (!global.Olm) {
-        logger.warn('not running megolm tests: Olm not present');
-        return;
-    }
-    const Olm = global.Olm;
-    let testOlmAccount: Olm.Account;
-    let aliceTestClient: TestClient;
-
-    const setupTestClient = (): [Account, TestClient] => {
-        const aliceTestClient = new TestClient(
-            "@alice:localhost", "xzcvb", "akjgkrgjs",
-        );
-        const testOlmAccount = new Olm.Account();
-        testOlmAccount!.create();
-
-        return [testOlmAccount, aliceTestClient];
-    };
-
-    beforeAll(function() {
-        return Olm.init();
-    });
-
-    beforeEach(async function() {
-        [testOlmAccount, aliceTestClient] = setupTestClient();
-        await aliceTestClient!.client.initCrypto();
-        aliceTestClient!.client.crypto!.backupManager.backupInfo = CURVE25519_BACKUP_INFO;
-    });
-
-    afterEach(function() {
-        return aliceTestClient!.stop();
-    });
-
-    it("Alice checks key backups when receiving a message she can't decrypt", function() {
-        const syncResponse = {
-            next_batch: 1,
-            rooms: {
-                join: {},
-            },
-        };
-        syncResponse.rooms.join[ROOM_ID] = {
-            timeline: {
-                events: [ENCRYPTED_EVENT],
-            },
-        };
-
-        return aliceTestClient!.start().then(() => {
-            return createOlmSession(testOlmAccount, aliceTestClient);
-        }).then(() => {
-            const privkey = decodeRecoveryKey(RECOVERY_KEY);
-            return aliceTestClient!.client!.crypto!.storeSessionBackupPrivateKey(privkey);
-        }).then(() => {
-            aliceTestClient!.httpBackend.when("GET", "/sync").respond(200, syncResponse);
-            aliceTestClient!.expectKeyBackupQuery(
-                ROOM_ID,
-                SESSION_ID,
-                200,
-                CURVE25519_KEY_BACKUP_DATA,
-            );
-            return aliceTestClient!.httpBackend.flushAllExpected();
-        }).then(function(): Promise<MatrixEvent> {
-            const room = aliceTestClient!.client.getRoom(ROOM_ID)!;
-            const event = room.getLiveTimeline().getEvents()[0];
-
-            if (event.getContent()) {
-                return Promise.resolve(event);
-            }
-
-            return new Promise((resolve, reject) => {
-                event.once(MatrixEventEvent.Decrypted, (ev) => {
-                    logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
-                    resolve(ev);
-                });
-            });
-        }).then((event) => {
-            expect(event.getContent()).toEqual('testytest');
-        });
-    });
-});
@@ -0,0 +1,968 @@
+/*
+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() {
+        return 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',
+                };
+            });
+
+            // Grab the event that we'll need to resend
+            const room = aliceTestClient.client.getRoom(ROOM_ID);
+            const pendingEvents = room.getPendingEvents();
+            expect(pendingEvents.length).toEqual(1);
+            const unsentEvent = pendingEvents[0];
+
+            return Promise.all([
+                aliceTestClient.client.resendEvent(unsentEvent, room),
+
+                // 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,812 +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-next-line no-restricted-imports
-import MockHttpBackend from "matrix-mock-request";
-import { fail } from "assert";
-
-import { SlidingSync, SlidingSyncEvent, MSC3575RoomData, SlidingSyncState, Extension } from "../../src/sliding-sync";
-import { TestClient } from "../TestClient";
-import { IRoomEvent, IStateEvent } from "../../src/sync-accumulator";
-import {
-    MatrixClient, MatrixEvent, NotificationCountType, JoinRule, MatrixError,
-    EventType, IPushRules, PushRuleKind, TweakName, ClientEvent, RoomMemberEvent,
-} from "../../src";
-import { SlidingSyncSdk } from "../../src/sliding-sync-sdk";
-import { SyncState } from "../../src/sync";
-import { IStoredClientOpts } from "../../src/client";
-import { logger } from "../../src/logger";
-import { emitPromise } from "../test-utils/test-utils";
-
-describe("SlidingSyncSdk", () => {
-    let client: MatrixClient | undefined;
-    let httpBackend: MockHttpBackend | undefined;
-    let sdk: SlidingSyncSdk | undefined;
-    let mockSlidingSync: SlidingSync | undefined;
-    const selfUserId = "@alice:localhost";
-    const selfAccessToken = "aseukfgwef";
-
-    const mockifySlidingSync = (s: SlidingSync): SlidingSync => {
-        s.getList = jest.fn();
-        s.getListData = jest.fn();
-        s.getRoomSubscriptions = jest.fn();
-        s.listLength = jest.fn();
-        s.modifyRoomSubscriptionInfo = jest.fn();
-        s.modifyRoomSubscriptions = jest.fn();
-        s.registerExtension = jest.fn();
-        s.setList = jest.fn();
-        s.setListRanges = jest.fn();
-        s.start = jest.fn();
-        s.stop = jest.fn();
-        s.resend = jest.fn();
-        return s;
-    };
-
-    // shorthand way to make events without filling in all the fields
-    let eventIdCounter = 0;
-    const mkOwnEvent = (evType: string, content: object): IRoomEvent => {
-        eventIdCounter++;
-        return {
-            type: evType,
-            content: content,
-            sender: selfUserId,
-            origin_server_ts: Date.now(),
-            event_id: "$" + eventIdCounter,
-        };
-    };
-    const mkOwnStateEvent = (evType: string, content: object, stateKey = ''): IStateEvent => {
-        eventIdCounter++;
-        return {
-            type: evType,
-            state_key: stateKey,
-            content: content,
-            sender: selfUserId,
-            origin_server_ts: Date.now(),
-            event_id: "$" + eventIdCounter,
-        };
-    };
-    const assertTimelineEvents = (got: MatrixEvent[], want: IRoomEvent[]): void => {
-        expect(got.length).toEqual(want.length);
-        got.forEach((m, i) => {
-            expect(m.getType()).toEqual(want[i].type);
-            expect(m.getSender()).toEqual(want[i].sender);
-            expect(m.getId()).toEqual(want[i].event_id);
-            expect(m.getContent()).toEqual(want[i].content);
-            expect(m.getTs()).toEqual(want[i].origin_server_ts);
-            if (want[i].unsigned) {
-                expect(m.getUnsigned()).toEqual(want[i].unsigned);
-            }
-            const maybeStateEvent = want[i] as IStateEvent;
-            if (maybeStateEvent.state_key) {
-                expect(m.getStateKey()).toEqual(maybeStateEvent.state_key);
-            }
-        });
-    };
-
-    // assign client/httpBackend globals
-    const setupClient = async (testOpts?: Partial<IStoredClientOpts&{withCrypto: boolean}>) => {
-        testOpts = testOpts || {};
-        const testClient = new TestClient(selfUserId, "DEVICE", selfAccessToken);
-        httpBackend = testClient.httpBackend;
-        client = testClient.client;
-        mockSlidingSync = mockifySlidingSync(new SlidingSync("", [], {}, client, 0));
-        if (testOpts.withCrypto) {
-            httpBackend!.when("GET", "/room_keys/version").respond(404, {});
-            await client!.initCrypto();
-            testOpts.crypto = client!.crypto;
-        }
-        httpBackend!.when("GET", "/_matrix/client/r0/pushrules").respond(200, {});
-        sdk = new SlidingSyncSdk(mockSlidingSync, client, testOpts);
-    };
-
-    // tear down client/httpBackend globals
-    const teardownClient = () => {
-        client!.stopClient();
-        return httpBackend!.stop();
-    };
-
-    // find an extension on a SlidingSyncSdk instance
-    const findExtension = (name: string): Extension => {
-        expect(mockSlidingSync!.registerExtension).toHaveBeenCalled();
-        const mockFn = mockSlidingSync!.registerExtension as jest.Mock;
-        // find the extension
-        for (let i = 0; i < mockFn.mock.calls.length; i++) {
-            const calledExtension = mockFn.mock.calls[i][0] as Extension;
-            if (calledExtension && calledExtension.name() === name) {
-                return calledExtension;
-            }
-        }
-        fail("cannot find extension " + name);
-    };
-
-    describe("sync/stop", () => {
-        beforeAll(async () => {
-            await setupClient();
-        });
-        afterAll(teardownClient);
-        it("can sync()", async () => {
-            const hasSynced = sdk!.sync();
-            await httpBackend!.flushAllExpected();
-            await hasSynced;
-            expect(mockSlidingSync!.start).toBeCalled();
-        });
-        it("can stop()", async () => {
-            sdk!.stop();
-            expect(mockSlidingSync!.stop).toBeCalled();
-        });
-    });
-
-    describe("rooms", () => {
-        beforeAll(async () => {
-            await setupClient();
-        });
-        afterAll(teardownClient);
-
-        describe("initial", () => {
-            beforeAll(async () => {
-                const hasSynced = sdk!.sync();
-                await httpBackend!.flushAllExpected();
-                await hasSynced;
-            });
-            // inject some rooms with different fields set.
-            // All rooms are new so they all have initial: true
-            const roomA = "!a_state_and_timeline:localhost";
-            const roomB = "!b_timeline_only:localhost";
-            const roomC = "!c_with_highlight_count:localhost";
-            const roomD = "!d_with_notif_count:localhost";
-            const roomE = "!e_with_invite:localhost";
-            const roomF = "!f_calc_room_name:localhost";
-            const roomG = "!g_join_invite_counts:localhost";
-            const data: Record<string, MSC3575RoomData> = {
-                [roomA]: {
-                    name: "A",
-                    required_state: [
-                        mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
-                        mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
-                        mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
-                        mkOwnStateEvent(EventType.RoomName, { name: "A" }, ""),
-                    ],
-                    timeline: [
-                        mkOwnEvent(EventType.RoomMessage, { body: "hello A" }),
-                        mkOwnEvent(EventType.RoomMessage, { body: "world A" }),
-                    ],
-                    initial: true,
-                },
-                [roomB]: {
-                    name: "B",
-                    required_state: [],
-                    timeline: [
-                        mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
-                        mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
-                        mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
-                        mkOwnEvent(EventType.RoomMessage, { body: "hello B" }),
-                        mkOwnEvent(EventType.RoomMessage, { body: "world B" }),
-
-                    ],
-                    initial: true,
-                },
-                [roomC]: {
-                    name: "C",
-                    required_state: [],
-                    timeline: [
-                        mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
-                        mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
-                        mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
-                        mkOwnEvent(EventType.RoomMessage, { body: "hello C" }),
-                        mkOwnEvent(EventType.RoomMessage, { body: "world C" }),
-                    ],
-                    highlight_count: 5,
-                    initial: true,
-                },
-                [roomD]: {
-                    name: "D",
-                    required_state: [],
-                    timeline: [
-                        mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
-                        mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
-                        mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
-                        mkOwnEvent(EventType.RoomMessage, { body: "hello D" }),
-                        mkOwnEvent(EventType.RoomMessage, { body: "world D" }),
-                    ],
-                    notification_count: 5,
-                    initial: true,
-                },
-                [roomE]: {
-                    name: "E",
-                    required_state: [],
-                    timeline: [],
-                    invite_state: [
-                        {
-                            type: EventType.RoomMember,
-                            content: { membership: "invite" },
-                            state_key: selfUserId,
-                            sender: "@bob:localhost",
-                            event_id: "$room_e_invite",
-                            origin_server_ts: 123456,
-                        },
-                        {
-                            type: "m.room.join_rules",
-                            content: { join_rule: "invite" },
-                            state_key: "",
-                            sender: "@bob:localhost",
-                            event_id: "$room_e_join_rule",
-                            origin_server_ts: 123456,
-                        },
-                    ],
-                    initial: true,
-                },
-                [roomF]: {
-                    name: "#foo:localhost",
-                    required_state: [
-                        mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
-                        mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
-                        mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
-                        mkOwnStateEvent(EventType.RoomCanonicalAlias, { alias: "#foo:localhost" }, ""),
-                        mkOwnStateEvent(EventType.RoomName, { name: "This should be ignored" }, ""),
-                    ],
-                    timeline: [
-                        mkOwnEvent(EventType.RoomMessage, { body: "hello A" }),
-                        mkOwnEvent(EventType.RoomMessage, { body: "world A" }),
-                    ],
-                    initial: true,
-                },
-                [roomG]: {
-                    name: "G",
-                    required_state: [],
-                    timeline: [
-                        mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
-                        mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
-                        mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
-                    ],
-                    joined_count: 5,
-                    invited_count: 2,
-                    initial: true,
-                },
-            };
-
-            it("can be created with required_state and timeline", () => {
-                mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomA, data[roomA]);
-                const gotRoom = client!.getRoom(roomA);
-                expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(gotRoom.name).toEqual(data[roomA].name);
-                expect(gotRoom.getMyMembership()).toEqual("join");
-                assertTimelineEvents(gotRoom.getLiveTimeline().getEvents().slice(-2), data[roomA].timeline);
-            });
-
-            it("can be created with timeline only", () => {
-                mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomB, data[roomB]);
-                const gotRoom = client!.getRoom(roomB);
-                expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(gotRoom.name).toEqual(data[roomB].name);
-                expect(gotRoom.getMyMembership()).toEqual("join");
-                assertTimelineEvents(gotRoom.getLiveTimeline().getEvents().slice(-5), data[roomB].timeline);
-            });
-
-            it("can be created with a highlight_count", () => {
-                mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomC, data[roomC]);
-                const gotRoom = client!.getRoom(roomC);
-                expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(
-                    gotRoom.getUnreadNotificationCount(NotificationCountType.Highlight),
-                ).toEqual(data[roomC].highlight_count);
-            });
-
-            it("can be created with a notification_count", () => {
-                mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomD, data[roomD]);
-                const gotRoom = client!.getRoom(roomD);
-                expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(
-                    gotRoom.getUnreadNotificationCount(NotificationCountType.Total),
-                ).toEqual(data[roomD].notification_count);
-            });
-
-            it("can be created with an invited/joined_count", () => {
-                mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomG, data[roomG]);
-                const gotRoom = client!.getRoom(roomG);
-                expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(gotRoom.getInvitedMemberCount()).toEqual(data[roomG].invited_count);
-                expect(gotRoom.getJoinedMemberCount()).toEqual(data[roomG].joined_count);
-            });
-
-            it("can be created with invite_state", () => {
-                mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomE, data[roomE]);
-                const gotRoom = client!.getRoom(roomE);
-                expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(gotRoom.getMyMembership()).toEqual("invite");
-                expect(gotRoom.currentState.getJoinRule()).toEqual(JoinRule.Invite);
-            });
-
-            it("uses the 'name' field to caluclate the room name", () => {
-                mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomF, data[roomF]);
-                const gotRoom = client!.getRoom(roomF);
-                expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(
-                    gotRoom.name,
-                ).toEqual(data[roomF].name);
-            });
-
-            describe("updating", () => {
-                it("can update with a new timeline event", async () => {
-                    const newEvent = mkOwnEvent(EventType.RoomMessage, { body: "new event A" });
-                    mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomA, {
-                        timeline: [newEvent],
-                        required_state: [],
-                        name: data[roomA].name,
-                    });
-                    const gotRoom = client!.getRoom(roomA);
-                    expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
-                    const newTimeline = data[roomA].timeline;
-                    newTimeline.push(newEvent);
-                    assertTimelineEvents(gotRoom.getLiveTimeline().getEvents().slice(-3), newTimeline);
-                });
-
-                it("can update with a new required_state event", async () => {
-                    let gotRoom = client!.getRoom(roomB);
-                    expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
-                    expect(gotRoom.getJoinRule()).toEqual(JoinRule.Invite); // default
-                    mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomB, {
-                        required_state: [
-                            mkOwnStateEvent("m.room.join_rules", { join_rule: "restricted" }, ""),
-                        ],
-                        timeline: [],
-                        name: data[roomB].name,
-                    });
-                    gotRoom = client!.getRoom(roomB);
-                    expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
-                    expect(gotRoom.getJoinRule()).toEqual(JoinRule.Restricted);
-                });
-
-                it("can update with a new highlight_count", async () => {
-                    mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomC, {
-                        name: data[roomC].name,
-                        required_state: [],
-                        timeline: [],
-                        highlight_count: 1,
-                    });
-                    const gotRoom = client!.getRoom(roomC);
-                    expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
-                    expect(
-                        gotRoom.getUnreadNotificationCount(NotificationCountType.Highlight),
-                    ).toEqual(1);
-                });
-
-                it("can update with a new notification_count", async () => {
-                    mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomD, {
-                        name: data[roomD].name,
-                        required_state: [],
-                        timeline: [],
-                        notification_count: 1,
-                    });
-                    const gotRoom = client!.getRoom(roomD);
-                    expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
-                    expect(
-                        gotRoom.getUnreadNotificationCount(NotificationCountType.Total),
-                    ).toEqual(1);
-                });
-
-                it("can update with a new joined_count", () => {
-                    mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomG, {
-                        name: data[roomD].name,
-                        required_state: [],
-                        timeline: [],
-                        joined_count: 1,
-                    });
-                    const gotRoom = client!.getRoom(roomG);
-                    expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
-                    expect(gotRoom.getJoinedMemberCount()).toEqual(1);
-                });
-
-                // Regression test for a bug which caused the timeline entries to be out-of-order
-                // when the same room appears twice with different timeline limits. E.g appears in
-                // the list with timeline_limit:1 then appears again as a room subscription with
-                // timeline_limit:50
-                it("can return history with a larger timeline_limit", async () => {
-                    const timeline = data[roomA].timeline;
-                    const oldTimeline = [
-                        mkOwnEvent(EventType.RoomMessage, { body: "old event A" }),
-                        mkOwnEvent(EventType.RoomMessage, { body: "old event B" }),
-                        mkOwnEvent(EventType.RoomMessage, { body: "old event C" }),
-                        ...timeline,
-                    ];
-                    mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomA, {
-                        timeline: oldTimeline,
-                        required_state: [],
-                        name: data[roomA].name,
-                        initial: true, // e.g requested via room subscription
-                    });
-                    const gotRoom = client!.getRoom(roomA);
-                    expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
-
-                    logger.log("want:", oldTimeline.map((e) => (e.type + " : " + (e.content || {}).body)));
-                    logger.log("got:", gotRoom.getLiveTimeline().getEvents().map(
-                        (e) => (e.getType() + " : " + e.getContent().body)),
-                    );
-
-                    // we expect the timeline now to be oldTimeline (so the old events are in fact old)
-                    assertTimelineEvents(gotRoom.getLiveTimeline().getEvents(), oldTimeline);
-                });
-            });
-        });
-    });
-
-    describe("lifecycle", () => {
-        beforeAll(async () => {
-            await setupClient();
-            const hasSynced = sdk!.sync();
-            await httpBackend!.flushAllExpected();
-            await hasSynced;
-        });
-        const FAILED_SYNC_ERROR_THRESHOLD = 3; // would be nice to export the const in the actual class...
-
-        it("emits SyncState.Reconnecting when < FAILED_SYNC_ERROR_THRESHOLD & SyncState.Error when over", async () => {
-            mockSlidingSync!.emit(
-                SlidingSyncEvent.Lifecycle, SlidingSyncState.Complete,
-                { pos: "h", lists: [], rooms: {}, extensions: {} },
-            );
-            expect(sdk!.getSyncState()).toEqual(SyncState.Syncing);
-
-            mockSlidingSync!.emit(
-                SlidingSyncEvent.Lifecycle, SlidingSyncState.RequestFinished, null, new Error("generic"),
-            );
-            expect(sdk!.getSyncState()).toEqual(SyncState.Reconnecting);
-
-            for (let i = 0; i < FAILED_SYNC_ERROR_THRESHOLD; i++) {
-                mockSlidingSync!.emit(
-                    SlidingSyncEvent.Lifecycle, SlidingSyncState.RequestFinished, null, new Error("generic"),
-                );
-            }
-            expect(sdk!.getSyncState()).toEqual(SyncState.Error);
-        });
-
-        it("emits SyncState.Syncing after a previous SyncState.Error", async () => {
-            mockSlidingSync!.emit(
-                SlidingSyncEvent.Lifecycle,
-                SlidingSyncState.Complete,
-                { pos: "i", lists: [], rooms: {}, extensions: {} },
-            );
-            expect(sdk!.getSyncState()).toEqual(SyncState.Syncing);
-        });
-
-        it("emits SyncState.Error immediately when receiving M_UNKNOWN_TOKEN and stops syncing", async () => {
-            expect(mockSlidingSync!.stop).not.toBeCalled();
-            mockSlidingSync!.emit(SlidingSyncEvent.Lifecycle, SlidingSyncState.RequestFinished, null, new MatrixError({
-                errcode: "M_UNKNOWN_TOKEN",
-                message: "Oh no your access token is no longer valid",
-            }));
-            expect(sdk!.getSyncState()).toEqual(SyncState.Error);
-            expect(mockSlidingSync!.stop).toBeCalled();
-        });
-    });
-
-    describe("opts", () => {
-        afterEach(teardownClient);
-        it("can resolveProfilesToInvites", async () => {
-            await setupClient({
-                resolveInvitesToProfiles: true,
-            });
-            const roomId = "!resolveProfilesToInvites:localhost";
-            const invitee = "@invitee:localhost";
-            const inviteeProfile = {
-                avatar_url: "mxc://foobar",
-                displayname: "The Invitee",
-            };
-            httpBackend!.when("GET", "/profile").respond(200, inviteeProfile);
-            mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomId, {
-                initial: true,
-                name: "Room with Invite",
-                required_state: [],
-                timeline: [
-                    mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
-                    mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
-                    mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
-                    mkOwnStateEvent(EventType.RoomMember, { membership: "invite" }, invitee),
-                ],
-            });
-            await httpBackend!.flush("/profile", 1, 1000);
-            await emitPromise(client!, RoomMemberEvent.Name);
-            const room = client!.getRoom(roomId)!;
-            expect(room).toBeDefined();
-            const inviteeMember = room.getMember(invitee)!;
-            expect(inviteeMember).toBeDefined();
-            expect(inviteeMember.getMxcAvatarUrl()).toEqual(inviteeProfile.avatar_url);
-            expect(inviteeMember.name).toEqual(inviteeProfile.displayname);
-        });
-    });
-
-    describe("ExtensionE2EE", () => {
-        let ext: Extension;
-        beforeAll(async () => {
-            await setupClient({
-                withCrypto: true,
-            });
-            const hasSynced = sdk!.sync();
-            await httpBackend!.flushAllExpected();
-            await hasSynced;
-            ext = findExtension("e2ee");
-        });
-        afterAll(async () => {
-            // needed else we do some async operations in the background which can cause Jest to whine:
-            // "Cannot log after tests are done. Did you forget to wait for something async in your test?"
-            // Attempted to log "Saving device tracking data null"."
-            client!.crypto!.stop();
-        });
-        it("gets enabled on the initial request only", () => {
-            expect(ext.onRequest(true)).toEqual({
-                enabled: true,
-            });
-            expect(ext.onRequest(false)).toEqual(undefined);
-        });
-        it("can update device lists", () => {
-            ext.onResponse({
-                device_lists: {
-                    changed: ["@alice:localhost"],
-                    left: ["@bob:localhost"],
-                },
-            });
-            // TODO: more assertions?
-        });
-        it("can update OTK counts", () => {
-            client!.crypto!.updateOneTimeKeyCount = jest.fn();
-            ext.onResponse({
-                device_one_time_keys_count: {
-                    signed_curve25519: 42,
-                },
-            });
-            expect(client!.crypto!.updateOneTimeKeyCount).toHaveBeenCalledWith(42);
-            ext.onResponse({
-                device_one_time_keys_count: {
-                    not_signed_curve25519: 42,
-                    // missing field -> default to 0
-                },
-            });
-            expect(client!.crypto!.updateOneTimeKeyCount).toHaveBeenCalledWith(0);
-        });
-        it("can update fallback keys", () => {
-            ext.onResponse({
-                device_unused_fallback_key_types: ["signed_curve25519"],
-            });
-            expect(client!.crypto!.getNeedsNewFallback()).toEqual(false);
-            ext.onResponse({
-                device_unused_fallback_key_types: ["not_signed_curve25519"],
-            });
-            expect(client!.crypto!.getNeedsNewFallback()).toEqual(true);
-        });
-    });
-    describe("ExtensionAccountData", () => {
-        let ext: Extension;
-        beforeAll(async () => {
-            await setupClient();
-            const hasSynced = sdk!.sync();
-            await httpBackend!.flushAllExpected();
-            await hasSynced;
-            ext = findExtension("account_data");
-        });
-        it("gets enabled on the initial request only", () => {
-            expect(ext.onRequest(true)).toEqual({
-                enabled: true,
-            });
-            expect(ext.onRequest(false)).toEqual(undefined);
-        });
-        it("processes global account data", async () => {
-            const globalType = "global_test";
-            const globalContent = {
-                info: "here",
-            };
-            let globalData = client!.getAccountData(globalType);
-            expect(globalData).toBeUndefined();
-            ext.onResponse({
-                global: [
-                    {
-                        type: globalType,
-                        content: globalContent,
-                    },
-                ],
-            });
-            globalData = client!.getAccountData(globalType)!;
-            expect(globalData).toBeDefined();
-            expect(globalData.getContent()).toEqual(globalContent);
-        });
-        it("processes rooms account data", async () => {
-            const roomId = "!room:id";
-            mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomId, {
-                name: "Room with account data",
-                required_state: [],
-                timeline: [
-                    mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
-                    mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
-                    mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
-                    mkOwnEvent(EventType.RoomMessage, { body: "hello" }),
-
-                ],
-                initial: true,
-            });
-            const roomContent = {
-                foo: "bar",
-            };
-            const roomType = "test";
-            ext.onResponse({
-                rooms: {
-                    [roomId]: [
-                        {
-                            type: roomType,
-                            content: roomContent,
-                        },
-                    ],
-                },
-            });
-            const room = client!.getRoom(roomId)!;
-            expect(room).toBeDefined();
-            const event = room.getAccountData(roomType)!;
-            expect(event).toBeDefined();
-            expect(event.getContent()).toEqual(roomContent);
-        });
-        it("doesn't crash for unknown room account data", async () => {
-            const unknownRoomId = "!unknown:id";
-            const roomType = "tester";
-            ext.onResponse({
-                rooms: {
-                    [unknownRoomId]: [
-                        {
-                            type: roomType,
-                            content: {
-                                foo: "Bar",
-                            },
-                        },
-                    ],
-                },
-            });
-            const room = client!.getRoom(unknownRoomId);
-            expect(room).toBeNull();
-            expect(client!.getAccountData(roomType)).toBeUndefined();
-        });
-        it("can update push rules via account data", async () => {
-            const roomId = "!foo:bar";
-            const pushRulesContent: IPushRules = {
-                global: {
-                    [PushRuleKind.RoomSpecific]: [{
-                        enabled: true,
-                        default: true,
-                        pattern: "monkey",
-                        actions: [
-                            {
-                                set_tweak: TweakName.Sound,
-                                value: "default",
-                            },
-                        ],
-                        rule_id: roomId,
-                    }],
-                },
-            };
-            let pushRule = client!.getRoomPushRule("global", roomId);
-            expect(pushRule).toBeUndefined();
-            ext.onResponse({
-                global: [
-                    {
-                        type: EventType.PushRules,
-                        content: pushRulesContent,
-                    },
-                ],
-            });
-            pushRule = client!.getRoomPushRule("global", roomId)!;
-            expect(pushRule).toEqual(pushRulesContent.global[PushRuleKind.RoomSpecific]![0]);
-        });
-    });
-    describe("ExtensionToDevice", () => {
-        let ext: Extension;
-        beforeAll(async () => {
-            await setupClient();
-            const hasSynced = sdk!.sync();
-            await httpBackend!.flushAllExpected();
-            await hasSynced;
-            ext = findExtension("to_device");
-        });
-        it("gets enabled with a limit on the initial request only", () => {
-            const reqJson: any = ext.onRequest(true);
-            expect(reqJson.enabled).toEqual(true);
-            expect(reqJson.limit).toBeGreaterThan(0);
-            expect(reqJson.since).toBeUndefined();
-        });
-        it("updates the since value", async () => {
-            ext.onResponse({
-                next_batch: "12345",
-                events: [],
-            });
-            expect(ext.onRequest(false)).toEqual({
-                since: "12345",
-            });
-        });
-        it("can handle missing fields", async () => {
-            ext.onResponse({
-                next_batch: "23456",
-                // no events array
-            });
-        });
-        it("emits to-device events on the client", async () => {
-            const toDeviceType = "custom_test";
-            const toDeviceContent = {
-                foo: "bar",
-            };
-            let called = false;
-            client!.once(ClientEvent.ToDeviceEvent, (ev) => {
-                expect(ev.getContent()).toEqual(toDeviceContent);
-                expect(ev.getType()).toEqual(toDeviceType);
-                called = true;
-            });
-            ext.onResponse({
-                next_batch: "34567",
-                events: [
-                    {
-                        type: toDeviceType,
-                        content: toDeviceContent,
-                    },
-                ],
-            });
-            expect(called).toBe(true);
-        });
-        it("can cancel key verification requests", async () => {
-            const seen: Record<string, boolean> = {};
-            client!.on(ClientEvent.ToDeviceEvent, (ev) => {
-                const evType = ev.getType();
-                expect(seen[evType]).toBeFalsy();
-                seen[evType] = true;
-                if (evType === "m.key.verification.start" || evType === "m.key.verification.request") {
-                    expect(ev.isCancelled()).toEqual(true);
-                } else {
-                    expect(ev.isCancelled()).toEqual(false);
-                }
-            });
-            ext.onResponse({
-                next_batch: "45678",
-                events: [
-                    // someone tries to verify keys
-                    {
-                        type: "m.key.verification.start",
-                        content: {
-                            transaction_id: "a",
-                        },
-                    },
-                    {
-                        type: "m.key.verification.request",
-                        content: {
-                            transaction_id: "a",
-                        },
-                    },
-                    // then gives up
-                    {
-                        type: "m.key.verification.cancel",
-                        content: {
-                            transaction_id: "a",
-                        },
-                    },
-                ],
-            });
-        });
-    });
-});
@@ -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");
-}
@@ -1,19 +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;
@@ -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,125 +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,94 +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),
-    getUser: jest.fn().mockReturnValue(new User(userId)),
-    isGuest: jest.fn().mockReturnValue(false),
-    mxcUrlToHttp: jest.fn().mockReturnValue('mock-mxcUrlToHttp'),
-    credentials: { userId },
-    getThreePids: jest.fn().mockResolvedValue({ threepids: [] }),
-    getAccessToken: jest.fn(),
-});
-
-/**
- * Returns basic mocked client methods related to rendering events
- * ```
- * const mockClient = getMockClientWithEventEmitter({
-        ...mockClientMethodsUser('@mytestuser:domain'),
-    });
- * ```
- */
-export const mockClientMethodsEvents = () => ({
-    decryptEventIfNeeded: jest.fn(),
-    getPushActionsForEvent: jest.fn(),
-});
-
-/**
- * Returns basic mocked client methods related to server support
- */
-export const mockClientMethodsServer = (): Partial<Record<MethodLikeKeys<MatrixClient>, unknown>> => ({
-    doesServerSupportSeparateAddAndBind: jest.fn(),
-    getIdentityServerUrl: jest.fn(),
-    getHomeserverUrl: jest.fn(),
-    getCapabilities: jest.fn().mockReturnValue({}),
-    doesServerSupportUnstableFeature: jest.fn().mockResolvedValue(false),
-});
-
@@ -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);
@@ -1,386 +0,0 @@
-// eslint-disable-next-line no-restricted-imports
-import EventEmitter from "events";
-
-// load olm before the sdk if possible
-import '../olm-loader';
-
-import { logger } from '../../src/logger';
-import { IContent, IEvent, IUnsigned, MatrixEvent, MatrixEventEvent } from "../../src/models/event";
-import { ClientEvent, EventType, IPusher, MatrixClient, MsgType } from "../../src";
-import { SyncState } from "../../src/sync";
-import { eventMapperFor } from "../../src/event-mapper";
-
-/**
- * Return a promise that is resolved when the client next emits a
- * SYNCING event.
- * @param {Object} client The client
- * @param {Number=} count Number of syncs to wait for (default 1)
- * @return {Promise} Resolves once the client has emitted a SYNCING event
- */
-export function syncPromise(client: MatrixClient, count = 1): Promise<void> {
-    if (count <= 0) {
-        return Promise.resolve();
-    }
-
-    const p = new Promise<void>((resolve) => {
-        const cb = (state: SyncState) => {
-            logger.log(`${Date.now()} syncPromise(${count}): ${state}`);
-            if (state === SyncState.Syncing) {
-                resolve();
-            } else {
-                client.once(ClientEvent.Sync, cb);
-            }
-        };
-        client.once(ClientEvent.Sync, cb);
-    });
-
-    return p.then(() => {
-        return syncPromise(client, count - 1);
-    });
-}
-
-/**
- * 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.
- */
-export function mock<T>(constr: { new(...args: any[]): T }, name: string): T {
-    // Based on http://eclipsesource.com/blogs/2014/03/27/mocks-in-jasmine-tests/
-    const HelperConstr = new Function(); // jshint ignore:line
-    HelperConstr.prototype = constr.prototype;
-    // @ts-ignore
-    const result = new HelperConstr();
-    result.toString = function() {
-        return "mock" + (name ? " of " + name : "");
-    };
-    for (const key of Object.getOwnPropertyNames(constr.prototype)) { // eslint-disable-line guard-for-in
-        try {
-            if (constr.prototype[key] instanceof Function) {
-                result[key] = jest.fn();
-            }
-        } 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;
-}
-
-interface IEventOpts {
-    type: EventType | string;
-    room?: string;
-    sender?: string;
-    skey?: string;
-    content: IContent;
-    prev_content?: IContent;
-    user?: string;
-    unsigned?: IUnsigned;
-    redacts?: string;
-}
-
-let testEventIndex = 1; // counter for events, easier for comparison of randomly generated events
-/**
- * Create an Event.
- * @param {Object} opts Values for the event.
- * @param {string} opts.type The event.type
- * @param {string} opts.room The event.room_id
- * @param {string} opts.sender The event.sender
- * @param {string} opts.skey Optional. The state key (auto inserts empty string)
- * @param {Object} opts.content The event.content
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @param {MatrixClient} client If passed along with opts.event=true will be used to set up re-emitters.
- * @return {Object} a JSON object representing this event.
- */
-export function mkEvent(opts: IEventOpts & { event: true }, client?: MatrixClient): MatrixEvent;
-export function mkEvent(opts: IEventOpts & { event?: false }, client?: MatrixClient): Partial<IEvent>;
-export function mkEvent(opts: IEventOpts & { event?: boolean }, client?: MatrixClient): Partial<IEvent> | MatrixEvent {
-    if (!opts.type || !opts.content) {
-        throw new Error("Missing .type or .content =>" + JSON.stringify(opts));
-    }
-    const event: Partial<IEvent> = {
-        type: opts.type as string,
-        room_id: opts.room,
-        sender: opts.sender || opts.user, // opts.user for backwards-compat
-        content: opts.content,
-        prev_content: opts.prev_content,
-        unsigned: opts.unsigned || {},
-        event_id: "$" + testEventIndex++ + "-" + Math.random() + "-" + Math.random(),
-        txn_id: "~" + Math.random(),
-        redacts: opts.redacts,
-    };
-    if (opts.skey !== undefined) {
-        event.state_key = opts.skey;
-    } else if ([
-        EventType.RoomName,
-        EventType.RoomTopic,
-        EventType.RoomCreate,
-        EventType.RoomJoinRules,
-        EventType.RoomPowerLevels,
-        EventType.RoomTopic,
-        "com.example.state",
-    ].includes(opts.type)) {
-        event.state_key = "";
-    }
-
-    if (opts.event && client) {
-        return eventMapperFor(client, {})(event);
-    }
-
-    return opts.event ? new MatrixEvent(event) : event;
-}
-
-type GeneratedMetadata = {
-    event_id: string;
-    txn_id: string;
-    origin_server_ts: number;
-};
-
-export function mkEventCustom<T>(base: T): T & GeneratedMetadata {
-    return {
-        event_id: "$" + testEventIndex++ + "-" + Math.random() + "-" + Math.random(),
-        txn_id: "~" + Math.random(),
-        origin_server_ts: Date.now(),
-        ...base,
-    };
-}
-
-interface IPresenceOpts {
-    user?: string;
-    sender?: string;
-    url?: string;
-    name?: string;
-    ago?: number;
-    presence?: string;
-    event?: boolean;
-}
-
-/**
- * Create an m.presence event.
- * @param {Object} opts Values for the presence.
- * @return {Object|MatrixEvent} The event
- */
-export function mkPresence(opts: IPresenceOpts & { event: true }): MatrixEvent;
-export function mkPresence(opts: IPresenceOpts & { event?: false }): Partial<IEvent>;
-export function mkPresence(opts: IPresenceOpts & { event?: boolean }): Partial<IEvent> | MatrixEvent {
-    const event = {
-        event_id: "$" + Math.random() + "-" + Math.random(),
-        type: "m.presence",
-        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;
-}
-
-interface IMembershipOpts {
-    room?: string;
-    mship: string;
-    sender?: string;
-    user?: string;
-    skey?: string;
-    name?: string;
-    url?: string;
-    event?: boolean;
-}
-
-/**
- * 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
- */
-export function mkMembership(opts: IMembershipOpts & { event: true }): MatrixEvent;
-export function mkMembership(opts: IMembershipOpts & { event?: false }): Partial<IEvent>;
-export function mkMembership(opts: IMembershipOpts & { event?: boolean }): Partial<IEvent> | MatrixEvent {
-    const eventOpts: IEventOpts = {
-        ...opts,
-        type: EventType.RoomMember,
-        content: {
-            membership: opts.mship,
-        },
-    };
-
-    if (!opts.skey) {
-        eventOpts.skey = opts.sender || opts.user;
-    }
-    if (opts.name) {
-        eventOpts.content.displayname = opts.name;
-    }
-    if (opts.url) {
-        eventOpts.content.avatar_url = opts.url;
-    }
-    return mkEvent(eventOpts);
-}
-
-export function mkMembershipCustom<T>(
-    base: T & { membership: string, sender: string, content?: IContent },
-): T & { type: EventType, sender: string, state_key: string, content: IContent } & GeneratedMetadata {
-    const content = base.content || {};
-    return mkEventCustom({
-        ...base,
-        content: { ...content, membership: base.membership },
-        type: EventType.RoomMember,
-        state_key: base.sender,
-    });
-}
-
-interface IMessageOpts {
-    room?: string;
-    user: string;
-    msg?: string;
-    event?: boolean;
-}
-
-/**
- * Create an m.room.message event.
- * @param {Object} opts Values for the message
- * @param {string} opts.room The room ID for the event.
- * @param {string} opts.user The user ID for the event.
- * @param {string} opts.msg Optional. The content.body for the event.
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @param {MatrixClient} client If passed along with opts.event=true will be used to set up re-emitters.
- * @return {Object|MatrixEvent} The event
- */
-export function mkMessage(opts: IMessageOpts & { event: true }, client?: MatrixClient): MatrixEvent;
-export function mkMessage(opts: IMessageOpts & { event?: false }, client?: MatrixClient): Partial<IEvent>;
-export function mkMessage(
-    opts: IMessageOpts & { event?: boolean },
-    client?: MatrixClient,
-): Partial<IEvent> | MatrixEvent {
-    const eventOpts: IEventOpts = {
-        ...opts,
-        type: EventType.RoomMessage,
-        content: {
-            msgtype: MsgType.Text,
-            body: opts.msg,
-        },
-    };
-
-    if (!eventOpts.content.body) {
-        eventOpts.content.body = "Random->" + Math.random();
-    }
-    return mkEvent(eventOpts, client);
-}
-
-interface IReplyMessageOpts extends IMessageOpts {
-    replyToMessage: MatrixEvent;
-}
-
-/**
- * Create a reply message.
- *
- * @param {Object} opts Values for the message
- * @param {string} opts.room The room ID for the event.
- * @param {string} opts.user The user ID for the event.
- * @param {string} opts.msg Optional. The content.body for the event.
- * @param {MatrixEvent} opts.replyToMessage The replied message
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @param {MatrixClient} client If passed along with opts.event=true will be used to set up re-emitters.
- * @return {Object|MatrixEvent} The event
- */
-export function mkReplyMessage(opts: IReplyMessageOpts & { event: true }, client?: MatrixClient): MatrixEvent;
-export function mkReplyMessage(opts: IReplyMessageOpts & { event?: false }, client?: MatrixClient): Partial<IEvent>;
-export function mkReplyMessage(
-    opts: IReplyMessageOpts & { event?: boolean },
-    client?: MatrixClient,
-): Partial<IEvent> | MatrixEvent {
-    const eventOpts: IEventOpts = {
-        ...opts,
-        type: EventType.RoomMessage,
-        content: {
-            "msgtype": MsgType.Text,
-            "body": opts.msg,
-            "m.relates_to": {
-                "rel_type": "m.in_reply_to",
-                "event_id": opts.replyToMessage.getId(),
-                "m.in_reply_to": {
-                    "event_id": opts.replyToMessage.getId()!,
-                },
-            },
-        },
-    };
-
-    if (!eventOpts.content.body) {
-        eventOpts.content.body = "Random->" + Math.random();
-    }
-    return mkEvent(eventOpts, client);
-}
-
-/**
- * A mock implementation of webstorage
- *
- * @constructor
- */
-export class MockStorageApi {
-    private data: Record<string, any> = {};
-
-    public get length() {
-        return Object.keys(this.data).length;
-    }
-
-    public key(i: number): any {
-        return Object.keys(this.data)[i];
-    }
-
-    public setItem(k: string, v: any): void {
-        this.data[k] = v;
-    }
-
-    public getItem(k: string): any {
-        return this.data[k] || null;
-    }
-
-    public removeItem(k: string): void {
-        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
- */
-export async function awaitDecryption(event: MatrixEvent): Promise<MatrixEvent> {
-    // An event is not always decrypted ahead of time
-    // getClearContent is a good signal to know whether an event has been decrypted
-    // already
-    if (event.getClearContent() !== null) {
-        return event;
-    } else {
-        logger.log(`${Date.now()} event ${event.getId()} is being decrypted; waiting`);
-
-        return new Promise((resolve) => {
-            event.once(MatrixEventEvent.Decrypted, (ev) => {
-                logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
-                resolve(ev);
-            });
-        });
-    }
-}
-
-export const emitPromise = (e: EventEmitter, k: string): Promise<any> => new Promise(r => e.once(k, r));
-
-export const mkPusher = (extra: Partial<IPusher> = {}): IPusher => ({
-    app_display_name: "app",
-    app_id: "123",
-    data: {},
-    device_display_name: "name",
-    kind: "http",
-    lang: "en",
-    pushkey: "pushpush",
-    ...extra,
-});
@@ -1,146 +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.
-*/
-
-export const DUMMY_SDP = (
-    "v=0\r\n" +
-    "o=- 5022425983810148698 2 IN IP4 127.0.0.1\r\n" +
-    "s=-\r\nt=0 0\r\na=group:BUNDLE 0\r\n" +
-    "a=msid-semantic: WMS h3wAi7s8QpiQMH14WG3BnDbmlOqo9I5ezGZA\r\n" +
-    "m=audio 9 UDP/TLS/RTP/SAVPF 111 103 104 9 0 8 106 105 13 110 112 113 126\r\n" +
-    "c=IN IP4 0.0.0.0\r\na=rtcp:9 IN IP4 0.0.0.0\r\na=ice-ufrag:hLDR\r\n" +
-    "a=ice-pwd:bMGD9aOldHWiI+6nAq/IIlRw\r\n" +
-    "a=ice-options:trickle\r\n" +
-    "a=fingerprint:sha-256 E4:94:84:F9:4A:98:8A:56:F5:5F:FD:AF:72:B9:32:89:49:5C:4B:9A:" +
-    "4A:15:8E:41:8A:F3:69:E4:39:52:DC:D6\r\n" +
-    "a=setup:active\r\n" +
-    "a=mid:0\r\n" +
-    "a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n" +
-    "a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n" +
-    "a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r\n" +
-    "a=extmap:4 urn:ietf:params:rtp-hdrext:sdes:mid\r\n" +
-    "a=extmap:5 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id\r\n" +
-    "a=extmap:6 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id\r\n" +
-    "a=sendrecv\r\n" +
-    "a=msid:h3wAi7s8QpiQMH14WG3BnDbmlOqo9I5ezGZA 4357098f-3795-4131-bff4-9ba9c0348c49\r\n" +
-    "a=rtcp-mux\r\n" +
-    "a=rtpmap:111 opus/48000/2\r\n" +
-    "a=rtcp-fb:111 transport-cc\r\n" +
-    "a=fmtp:111 minptime=10;useinbandfec=1\r\n" +
-    "a=rtpmap:103 ISAC/16000\r\n" +
-    "a=rtpmap:104 ISAC/32000\r\n" +
-    "a=rtpmap:9 G722/8000\r\n" +
-    "a=rtpmap:0 PCMU/8000\r\n" +
-    "a=rtpmap:8 PCMA/8000\r\n" +
-    "a=rtpmap:106 CN/32000\r\n" +
-    "a=rtpmap:105 CN/16000\r\n" +
-    "a=rtpmap:13 CN/8000\r\n" +
-    "a=rtpmap:110 telephone-event/48000\r\n" +
-    "a=rtpmap:112 telephone-event/32000\r\n" +
-    "a=rtpmap:113 telephone-event/16000\r\n" +
-    "a=rtpmap:126 telephone-event/8000\r\n" +
-    "a=ssrc:3619738545 cname:2RWtmqhXLdoF4sOi\r\n"
-);
-
-export class MockRTCPeerConnection {
-    localDescription: RTCSessionDescription;
-
-    constructor() {
-        this.localDescription = {
-            sdp: DUMMY_SDP,
-            type: 'offer',
-            toJSON: function() { },
-        };
-    }
-
-    addEventListener() { }
-    createDataChannel(label: string, opts: RTCDataChannelInit) { return { label, ...opts }; }
-    createOffer() {
-        return Promise.resolve({});
-    }
-    setRemoteDescription() {
-        return Promise.resolve();
-    }
-    setLocalDescription() {
-        return Promise.resolve();
-    }
-    close() { }
-    getStats() { return []; }
-    addTrack(track: MockMediaStreamTrack) { return new MockRTCRtpSender(track); }
-}
-
-export class MockRTCRtpSender {
-    constructor(public track: MockMediaStreamTrack) { }
-
-    replaceTrack(track: MockMediaStreamTrack) { this.track = track; }
-}
-
-export class MockMediaStreamTrack {
-    constructor(public readonly id: string, public readonly kind: "audio" | "video", public enabled = true) { }
-
-    stop() { }
-}
-
-// XXX: Using EventTarget in jest doesn't seem to work, so we write our own
-// implementation
-export class MockMediaStream {
-    constructor(
-        public id: string,
-        private tracks: MockMediaStreamTrack[] = [],
-    ) {}
-
-    listeners: [string, (...args: any[]) => any][] = [];
-
-    dispatchEvent(eventType: string) {
-        this.listeners.forEach(([t, c]) => {
-            if (t !== eventType) return;
-            c();
-        });
-    }
-    getTracks() { return this.tracks; }
-    getAudioTracks() { return this.tracks.filter((track) => track.kind === "audio"); }
-    getVideoTracks() { return this.tracks.filter((track) => track.kind === "video"); }
-    addEventListener(eventType: string, callback: (...args: any[]) => any) {
-        this.listeners.push([eventType, callback]);
-    }
-    removeEventListener(eventType: string, callback: (...args: any[]) => any) {
-        this.listeners.filter(([t, c]) => {
-            return t !== eventType || c !== callback;
-        });
-    }
-    addTrack(track: MockMediaStreamTrack) {
-        this.tracks.push(track);
-        this.dispatchEvent("addtrack");
-    }
-    removeTrack(track: MockMediaStreamTrack) { this.tracks.splice(this.tracks.indexOf(track), 1); }
-}
-
-export class MockMediaDeviceInfo {
-    constructor(
-        public kind: "audio" | "video",
-    ) { }
-}
-
-export class MockMediaHandler {
-    getUserMediaStream(audio: boolean, video: boolean) {
-        const tracks: MockMediaStreamTrack[] = [];
-        if (audio) tracks.push(new MockMediaStreamTrack("audio_track", "audio"));
-        if (video) tracks.push(new MockMediaStreamTrack("video_track", "video"));
-
-        return new MockMediaStream("mock_stream_from_media_handler", tracks);
-    }
-    stopUserMediaStream() { }
-    hasAudioDevice() { return true; }
-}
@@ -1,83 +0,0 @@
-/*
-Copyright 2021 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 { NamespacedValue, UnstableValue } from "../../src/NamespacedValue";
-
-describe("NamespacedValue", () => {
-    it("should prefer stable over unstable", () => {
-        const ns = new NamespacedValue("stable", "unstable");
-        expect(ns.name).toBe(ns.stable);
-        expect(ns.altName).toBe(ns.unstable);
-        expect(ns.names).toEqual([ns.stable, ns.unstable]);
-    });
-
-    it("should return unstable if there is no stable", () => {
-        const ns = new NamespacedValue(null, "unstable");
-        expect(ns.name).toBe(ns.unstable);
-        expect(ns.altName).toBeFalsy();
-        expect(ns.names).toEqual([ns.unstable]);
-    });
-
-    it("should have a falsey unstable if needed", () => {
-        const ns = new NamespacedValue("stable");
-        expect(ns.name).toBe(ns.stable);
-        expect(ns.altName).toBeFalsy();
-        expect(ns.names).toEqual([ns.stable]);
-    });
-
-    it("should match against either stable or unstable", () => {
-        const ns = new NamespacedValue("stable", "unstable");
-        expect(ns.matches("no")).toBe(false);
-        expect(ns.matches(ns.stable!)).toBe(true);
-        expect(ns.matches(ns.unstable!)).toBe(true);
-    });
-
-    it("should not permit falsey values for both parts", () => {
-        try {
-            new UnstableValue(null!, null!);
-            // noinspection ExceptionCaughtLocallyJS
-            throw new Error("Failed to fail");
-        } catch (e) {
-            expect((<Error>e).message).toBe("One of stable or unstable values must be supplied");
-        }
-    });
-});
-
-describe("UnstableValue", () => {
-    it("should prefer unstable over stable", () => {
-        const ns = new UnstableValue("stable", "unstable");
-        expect(ns.name).toBe(ns.unstable);
-        expect(ns.altName).toBe(ns.stable);
-        expect(ns.names).toEqual([ns.unstable, ns.stable]);
-    });
-
-    it("should return unstable if there is no stable", () => {
-        const ns = new UnstableValue(null!, "unstable");
-        expect(ns.name).toBe(ns.unstable);
-        expect(ns.altName).toBeFalsy();
-        expect(ns.names).toEqual([ns.unstable]);
-    });
-
-    it("should not permit falsey unstable values", () => {
-        try {
-            new UnstableValue("stable", null!);
-            // noinspection ExceptionCaughtLocallyJS
-            throw new Error("Failed to fail");
-        } catch (e) {
-            expect((<Error>e).message).toBe("Unstable value must be supplied");
-        }
-    });
-});
@@ -1,74 +0,0 @@
-/*
-Copyright 2021 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-next-line no-restricted-imports
-import { EventEmitter } from "events";
-
-import { ReEmitter } from "../../src/ReEmitter";
-
-const EVENTNAME = "UnknownEntry";
-
-class EventSource extends EventEmitter {
-    doTheThing() {
-        this.emit(EVENTNAME, "foo", "bar");
-    }
-
-    doAnError() {
-        this.emit('error');
-    }
-}
-
-class EventTarget extends EventEmitter {
-
-}
-
-describe("ReEmitter", function() {
-    it("Re-Emits events with the same args", function() {
-        const src = new EventSource();
-        const tgt = new EventTarget();
-
-        const handler = jest.fn();
-        tgt.on(EVENTNAME, handler);
-
-        const reEmitter = new ReEmitter(tgt);
-        reEmitter.reEmit(src, [EVENTNAME]);
-
-        src.doTheThing();
-
-        // Args should be the args passed to 'emit' after the event name, and
-        // also the source object of the event which re-emitter adds
-        expect(handler).toHaveBeenCalledWith("foo", "bar", src);
-    });
-
-    it("Doesn't throw if no handler for 'error' event", function() {
-        const src = new EventSource();
-        const tgt = new EventTarget();
-
-        const reEmitter = new ReEmitter(tgt);
-        reEmitter.reEmit(src, ['error']);
-
-        // without the workaround in ReEmitter, this would throw
-        src.doAnError();
-
-        const handler = jest.fn();
-        tgt.on('error', handler);
-
-        src.doAnError();
-
-        // Now we've attached an error handler, it should be called
-        expect(handler).toHaveBeenCalled();
-    });
-});
@@ -1,6 +1,5 @@
 /*
 Copyright 2018 New Vector Ltd
-Copyright 2019, 2022 The Matrix.org Foundation C.I.C.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -14,22 +13,30 @@ 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";

+import 'source-map-support/register';
+import Promise from 'bluebird';
+const sdk = require("../..");
+const utils = require("../test-utils");
+
+const AutoDiscovery = sdk.AutoDiscovery;
+
+import expect from 'expect';
 import MockHttpBackend from "matrix-mock-request";

-import { AutoDiscovery } from "../../src/autodiscovery";

 describe("AutoDiscovery", function() {
-    const getHttpBackend = (): MockHttpBackend => {
-        const httpBackend = new MockHttpBackend();
-        AutoDiscovery.setFetchFn(httpBackend.fetchFn as typeof global.fetch);
-        return httpBackend;
-    };
+    let httpBackend = null;
+
+    beforeEach(function() {
+        utils.beforeEach(this); // eslint-disable-line no-invalid-this
+        httpBackend = new MockHttpBackend();
+        sdk.request(httpBackend.requestFn);
+    });

    it("should throw an error when no domain is specified", function() {
-        getHttpBackend();
        return Promise.all([
-            // @ts-ignore testing no args
            AutoDiscovery.findClientConfig(/* no args */).then(() => {
                throw new Error("Expected a failure, not success with no args");
            }, () => {
@@ -42,13 +49,13 @@ describe("AutoDiscovery", function() {
                return true;
            }),

-            AutoDiscovery.findClientConfig(null as any).then(() => {
+            AutoDiscovery.findClientConfig(null).then(() => {
                throw new Error("Expected a failure, not success with null");
            }, () => {
                return true;
            }),

-            AutoDiscovery.findClientConfig(true as any).then(() => {
+            AutoDiscovery.findClientConfig(true).then(() => {
                throw new Error("Expected a failure, not success with a non-string");
            }, () => {
                return true;
@@ -57,7 +64,6 @@ describe("AutoDiscovery", function() {
    });

    it("should return PROMPT when .well-known 404s", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/.well-known/matrix/client").respond(404, {});
        return Promise.all([
            httpBackend.flushAllExpected(),
@@ -81,7 +87,6 @@ describe("AutoDiscovery", function() {
    });

    it("should return FAIL_PROMPT when .well-known returns a 500 error", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/.well-known/matrix/client").respond(500, {});
        return Promise.all([
            httpBackend.flushAllExpected(),
@@ -89,7 +94,7 @@ describe("AutoDiscovery", function() {
                const expected = {
                    "m.homeserver": {
                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
+                        error: "Invalid homeserver discovery response",
                        base_url: null,
                    },
                    "m.identity_server": {
@@ -105,7 +110,6 @@ describe("AutoDiscovery", function() {
    });

    it("should return FAIL_PROMPT when .well-known returns a 400 error", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/.well-known/matrix/client").respond(400, {});
        return Promise.all([
            httpBackend.flushAllExpected(),
@@ -113,7 +117,7 @@ describe("AutoDiscovery", function() {
                const expected = {
                    "m.homeserver": {
                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
+                        error: "Invalid homeserver discovery response",
                        base_url: null,
                    },
                    "m.identity_server": {
@@ -129,7 +133,6 @@ describe("AutoDiscovery", function() {
    });

    it("should return FAIL_PROMPT when .well-known returns an empty body", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "");
        return Promise.all([
            httpBackend.flushAllExpected(),
@@ -137,7 +140,7 @@ describe("AutoDiscovery", function() {
                const expected = {
                    "m.homeserver": {
                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
+                        error: "Invalid homeserver discovery response",
                        base_url: null,
                    },
                    "m.identity_server": {
@@ -152,31 +155,31 @@ describe("AutoDiscovery", function() {
        ]);
    });

-    it("should return FAIL_PROMPT when .well-known returns not-JSON", async () => {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "abc", true);
-        const expected = {
-            "m.homeserver": {
-                state: "FAIL_PROMPT",
-                error: AutoDiscovery.ERROR_INVALID,
-                base_url: null,
-            },
-            "m.identity_server": {
-                state: "PROMPT",
-                error: null,
-                base_url: null,
-            },
-        };
+    it("should return FAIL_PROMPT when .well-known returns not-JSON", function() {
+        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "abc");
        return Promise.all([
            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then(
-                expect(expected).toEqual,
-            ),
+            AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                const expected = {
+                    "m.homeserver": {
+                        state: "FAIL_PROMPT",
+                        error: "Invalid homeserver discovery response",
+                        base_url: null,
+                    },
+                    "m.identity_server": {
+                        state: "PROMPT",
+                        error: null,
+                        base_url: null,
+                    },
+                };
+
+                expect(conf).toEqual(expected);
+            }),
        ]);
    });

-    it("should return FAIL_PROMPT when .well-known does not have a base_url for m.homeserver (empty string)", () => {
-        const httpBackend = getHttpBackend();
+    it("should return FAIL_PROMPT when .well-known does not have a base_url for " +
+        "m.homeserver (empty string)", function() {
        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
            "m.homeserver": {
                base_url: "",
@@ -188,7 +191,7 @@ describe("AutoDiscovery", function() {
                const expected = {
                    "m.homeserver": {
                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
+                        error: "Invalid homeserver discovery response",
                        base_url: null,
                    },
                    "m.identity_server": {
@@ -203,8 +206,8 @@ describe("AutoDiscovery", function() {
        ]);
    });

-    it("should return FAIL_PROMPT when .well-known does not have a base_url for m.homeserver (no property)", () => {
-        const httpBackend = getHttpBackend();
+    it("should return FAIL_PROMPT when .well-known does not have a base_url for " +
+        "m.homeserver (no property)", function() {
        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
            "m.homeserver": {},
        });
@@ -214,7 +217,7 @@ describe("AutoDiscovery", function() {
                const expected = {
                    "m.homeserver": {
                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
+                        error: "Invalid homeserver discovery response",
                        base_url: null,
                    },
                    "m.identity_server": {
@@ -229,8 +232,8 @@ describe("AutoDiscovery", function() {
        ]);
    });

-    it("should return FAIL_ERROR when .well-known has an invalid base_url for m.homeserver (disallowed scheme)", () => {
-        const httpBackend = getHttpBackend();
+    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
+        "m.homeserver (disallowed scheme)", function() {
        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
            "m.homeserver": {
                base_url: "mxc://example.org",
@@ -242,7 +245,7 @@ describe("AutoDiscovery", function() {
                const expected = {
                    "m.homeserver": {
                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
+                        error: "Invalid homeserver discovery response",
                        base_url: null,
                    },
                    "m.identity_server": {
@@ -259,7 +262,6 @@ describe("AutoDiscovery", function() {

    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
        "m.homeserver (verification failure: 404)", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/_matrix/client/versions").respond(404, {});
        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
            "m.homeserver": {
@@ -272,8 +274,8 @@ describe("AutoDiscovery", function() {
                const expected = {
                    "m.homeserver": {
                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
-                        base_url: "https://example.org",
+                        error: "Invalid homeserver discovery response",
+                        base_url: null,
                    },
                    "m.identity_server": {
                        state: "PROMPT",
@@ -289,7 +291,6 @@ describe("AutoDiscovery", function() {

    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
        "m.homeserver (verification failure: 500)", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/_matrix/client/versions").respond(500, {});
        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
            "m.homeserver": {
@@ -302,8 +303,8 @@ describe("AutoDiscovery", function() {
                const expected = {
                    "m.homeserver": {
                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
-                        base_url: "https://example.org",
+                        error: "Invalid homeserver discovery response",
+                        base_url: null,
                    },
                    "m.identity_server": {
                        state: "PROMPT",
@@ -319,7 +320,6 @@ describe("AutoDiscovery", function() {

    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
        "m.homeserver (verification failure: 200 but wrong content)", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/_matrix/client/versions").respond(200, {
            not_matrix_versions: ["r0.0.1"],
        });
@@ -334,8 +334,8 @@ describe("AutoDiscovery", function() {
                const expected = {
                    "m.homeserver": {
                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
-                        base_url: "https://example.org",
+                        error: "Invalid homeserver discovery response",
+                        base_url: null,
                    },
                    "m.identity_server": {
                        state: "PROMPT",
@@ -351,9 +351,8 @@ describe("AutoDiscovery", function() {

    it("should return SUCCESS when .well-known has a verifiably accurate base_url for " +
        "m.homeserver", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path).toEqual("https://example.org/_matrix/client/versions");
+            expect(req.opts.uri).toEqual("https://example.org/_matrix/client/versions");
        }).respond(200, {
            versions: ["r0.0.1"],
        });
@@ -384,9 +383,8 @@ describe("AutoDiscovery", function() {
    });

    it("should return SUCCESS with the right homeserver URL", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
+            expect(req.opts.uri)
                .toEqual("https://chat.example.org/_matrix/client/versions");
        }).respond(200, {
            versions: ["r0.0.1"],
@@ -418,11 +416,10 @@ describe("AutoDiscovery", function() {
        ]);
    });

-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (missing base_url)", function() {
-        const httpBackend = getHttpBackend();
+    it("should return FAIL_ERROR when the identity server configuration is wrong " +
+        "(missing base_url)", function() {
        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
+            expect(req.opts.uri)
                .toEqual("https://chat.example.org/_matrix/client/versions");
        }).respond(200, {
            versions: ["r0.0.1"],
@@ -441,15 +438,15 @@ describe("AutoDiscovery", function() {
            AutoDiscovery.findClientConfig("example.org").then((conf) => {
                const expected = {
                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
+                        state: "FAIL_ERROR",
+                        error: "Invalid identity server discovery response",

                        // We still expect the base_url to be here for debugging purposes.
                        base_url: "https://chat.example.org",
                    },
                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
+                        state: "FAIL_ERROR",
+                        error: "Invalid identity server discovery response",
                        base_url: null,
                    },
                };
@@ -459,11 +456,10 @@ describe("AutoDiscovery", function() {
        ]);
    });

-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (empty base_url)", function() {
-        const httpBackend = getHttpBackend();
+    it("should return FAIL_ERROR when the identity server configuration is wrong " +
+        "(empty base_url)", function() {
        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
+            expect(req.opts.uri)
                .toEqual("https://chat.example.org/_matrix/client/versions");
        }).respond(200, {
            versions: ["r0.0.1"],
@@ -482,15 +478,15 @@ describe("AutoDiscovery", function() {
            AutoDiscovery.findClientConfig("example.org").then((conf) => {
                const expected = {
                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
+                        state: "FAIL_ERROR",
+                        error: "Invalid identity server discovery response",

                        // We still expect the base_url to be here for debugging purposes.
                        base_url: "https://chat.example.org",
                    },
                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
+                        state: "FAIL_ERROR",
+                        error: "Invalid identity server discovery response",
                        base_url: null,
                    },
                };
@@ -500,11 +496,10 @@ describe("AutoDiscovery", function() {
        ]);
    });

-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (validation error: 404)", function() {
-        const httpBackend = getHttpBackend();
+    it("should return FAIL_ERROR when the identity server configuration is wrong " +
+        "(validation error: 404)", function() {
        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
+            expect(req.opts.uri)
                .toEqual("https://chat.example.org/_matrix/client/versions");
        }).respond(200, {
            versions: ["r0.0.1"],
@@ -524,16 +519,16 @@ describe("AutoDiscovery", function() {
            AutoDiscovery.findClientConfig("example.org").then((conf) => {
                const expected = {
                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
+                        state: "FAIL_ERROR",
+                        error: "Invalid identity server discovery response",

                        // We still expect the base_url to be here for debugging purposes.
                        base_url: "https://chat.example.org",
                    },
                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
-                        base_url: "https://identity.example.org",
+                        state: "FAIL_ERROR",
+                        error: "Invalid identity server discovery response",
+                        base_url: null,
                    },
                };

@@ -542,11 +537,10 @@ describe("AutoDiscovery", function() {
        ]);
    });

-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (validation error: 500)", function() {
-        const httpBackend = getHttpBackend();
+    it("should return FAIL_ERROR when the identity server configuration is wrong " +
+        "(validation error: 500)", function() {
        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
+            expect(req.opts.uri)
                .toEqual("https://chat.example.org/_matrix/client/versions");
        }).respond(200, {
            versions: ["r0.0.1"],
@@ -566,16 +560,16 @@ describe("AutoDiscovery", function() {
            AutoDiscovery.findClientConfig("example.org").then((conf) => {
                const expected = {
                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
+                        state: "FAIL_ERROR",
+                        error: "Invalid identity server discovery response",

                        // We still expect the base_url to be here for debugging purposes
                        base_url: "https://chat.example.org",
                    },
                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
-                        base_url: "https://identity.example.org",
+                        state: "FAIL_ERROR",
+                        error: "Invalid identity server discovery response",
+                        base_url: null,
                    },
                };

@@ -586,15 +580,14 @@ describe("AutoDiscovery", function() {

    it("should return SUCCESS when the identity server configuration is " +
        "verifiably accurate", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
+            expect(req.opts.uri)
                .toEqual("https://chat.example.org/_matrix/client/versions");
        }).respond(200, {
            versions: ["r0.0.1"],
        });
        httpBackend.when("GET", "/_matrix/identity/api/v1").check((req) => {
-            expect(req.path)
+            expect(req.opts.uri)
                .toEqual("https://identity.example.org/_matrix/identity/api/v1");
        }).respond(200, {});
        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
@@ -629,15 +622,14 @@ describe("AutoDiscovery", function() {

    it("should return SUCCESS and preserve non-standard keys from the " +
        ".well-known response", function() {
-        const httpBackend = getHttpBackend();
        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
+            expect(req.opts.uri)
                .toEqual("https://chat.example.org/_matrix/client/versions");
        }).respond(200, {
            versions: ["r0.0.1"],
        });
        httpBackend.when("GET", "/_matrix/identity/api/v1").check((req) => {
-            expect(req.path)
+            expect(req.opts.uri)
                .toEqual("https://identity.example.org/_matrix/identity/api/v1");
        }).respond(200, {});
        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
@@ -675,76 +667,4 @@ describe("AutoDiscovery", function() {
            }),
        ]);
    });
-
-    it("should return FAIL_PROMPT for connection errors", () => {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/.well-known/matrix/client").fail(0, undefined!);
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_PROMPT for fetch errors", () => {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/.well-known/matrix/client").fail(0, new Error("CORS or something"));
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_PROMPT for invalid JSON", () => {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "<html>", true);
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID,
-                        base_url: null,
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
 });
@@ -1,256 +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 { REFERENCE_RELATION } from "matrix-events-sdk";
-
-import { LocationAssetType, M_ASSET, M_LOCATION, M_TIMESTAMP } from "../../src/@types/location";
-import { M_TOPIC } from "../../src/@types/topic";
-import {
-    makeBeaconContent,
-    makeBeaconInfoContent,
-    makeTopicContent,
-    parseBeaconContent,
-    parseTopicContent,
-} from "../../src/content-helpers";
-
-describe('Beacon content helpers', () => {
-    describe('makeBeaconInfoContent()', () => {
-        const mockDateNow = 123456789;
-        beforeEach(() => {
-            jest.spyOn(global.Date, 'now').mockReturnValue(mockDateNow);
-        });
-        afterAll(() => {
-            jest.spyOn(global.Date, 'now').mockRestore();
-        });
-        it('create fully defined event content', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                LocationAssetType.Pin,
-            )).toEqual({
-                description: 'nice beacon_info',
-                timeout: 1234,
-                live: true,
-                [M_TIMESTAMP.name]: mockDateNow,
-                [M_ASSET.name]: {
-                    type: LocationAssetType.Pin,
-                },
-            });
-        });
-
-        it('defaults timestamp to current time', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                LocationAssetType.Pin,
-            )).toEqual(expect.objectContaining({
-                [M_TIMESTAMP.name]: mockDateNow,
-            }));
-        });
-
-        it('uses timestamp when provided', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                LocationAssetType.Pin,
-                99999,
-            )).toEqual(expect.objectContaining({
-                [M_TIMESTAMP.name]: 99999,
-            }));
-        });
-
-        it('defaults asset type to self when not set', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                // no assetType passed
-            )).toEqual(expect.objectContaining({
-                [M_ASSET.name]: {
-                    type: LocationAssetType.Self,
-                },
-            }));
-        });
-    });
-
-    describe('makeBeaconContent()', () => {
-        it('creates event content without description', () => {
-            expect(makeBeaconContent(
-                'geo:foo',
-                123,
-                '$1234',
-                // no description
-            )).toEqual({
-                [M_LOCATION.name]: {
-                    description: undefined,
-                    uri: 'geo:foo',
-                },
-                [M_TIMESTAMP.name]: 123,
-                "m.relates_to": {
-                    rel_type: REFERENCE_RELATION.name,
-                    event_id: '$1234',
-                },
-            });
-        });
-
-        it('creates event content with description', () => {
-            expect(makeBeaconContent(
-                'geo:foo',
-                123,
-                '$1234',
-                'test description',
-            )).toEqual({
-                [M_LOCATION.name]: {
-                    description: 'test description',
-                    uri: 'geo:foo',
-                },
-                [M_TIMESTAMP.name]: 123,
-                "m.relates_to": {
-                    rel_type: REFERENCE_RELATION.name,
-                    event_id: '$1234',
-                },
-            });
-        });
-    });
-
-    describe("parseBeaconContent()", () => {
-        it("should not explode when parsing an invalid beacon", () => {
-            // deliberate cast to simulate wire content being invalid
-            const result = parseBeaconContent({} as any);
-            expect(result).toEqual({
-                description: undefined,
-                uri: undefined,
-                timestamp: undefined,
-            });
-        });
-
-        it("should parse unstable values", () => {
-            const uri = "urigoeshere";
-            const description = "descriptiongoeshere";
-            const timestamp = 1234;
-            const result = parseBeaconContent({
-                "org.matrix.msc3488.location": {
-                    uri,
-                    description,
-                },
-                "org.matrix.msc3488.ts": timestamp,
-
-                // relationship not used - just here to satisfy types
-                "m.relates_to": {
-                    rel_type: "m.reference",
-                    event_id: "$unused",
-                },
-            });
-            expect(result).toEqual({
-                description,
-                uri,
-                timestamp,
-            });
-        });
-
-        it("should parse stable values", () => {
-            const uri = "urigoeshere";
-            const description = "descriptiongoeshere";
-            const timestamp = 1234;
-            const result = parseBeaconContent({
-                "m.location": {
-                    uri,
-                    description,
-                },
-                "m.ts": timestamp,
-
-                // relationship not used - just here to satisfy types
-                "m.relates_to": {
-                    rel_type: "m.reference",
-                    event_id: "$unused",
-                },
-            });
-            expect(result).toEqual({
-                description,
-                uri,
-                timestamp,
-            });
-        });
-    });
-});
-
-describe('Topic content helpers', () => {
-    describe('makeTopicContent()', () => {
-        it('creates fully defined event content without html', () => {
-            expect(makeTopicContent("pizza")).toEqual({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                    mimetype: "text/plain",
-                }],
-            });
-        });
-
-        it('creates fully defined event content with html', () => {
-            expect(makeTopicContent("pizza", "<b>pizza</b>")).toEqual({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                    mimetype: "text/plain",
-                }, {
-                    body: "<b>pizza</b>",
-                    mimetype: "text/html",
-                }],
-            });
-        });
-    });
-
-    describe('parseTopicContent()', () => {
-        it('parses event content with plain text topic without mimetype', () => {
-            expect(parseTopicContent({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                }],
-            })).toEqual({
-                text: "pizza",
-            });
-        });
-
-        it('parses event content with plain text topic', () => {
-            expect(parseTopicContent({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                    mimetype: "text/plain",
-                }],
-            })).toEqual({
-                text: "pizza",
-            });
-        });
-
-        it('parses event content with html topic', () => {
-            expect(parseTopicContent({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "<b>pizza</b>",
-                    mimetype: "text/html",
-                }],
-            })).toEqual({
-                text: "pizza",
-                html: "<b>pizza</b>",
-            });
-        });
-    });
-});
@@ -0,0 +1,95 @@
+"use strict";
+import 'source-map-support/register';
+const ContentRepo = require("../../lib/content-repo");
+const testUtils = require("../test-utils");
+
+import expect from 'expect';
+
+describe("ContentRepo", function() {
+    const baseUrl = "https://my.home.server";
+
+    beforeEach(function() {
+        testUtils.beforeEach(this); // eslint-disable-line no-invalid-this
+    });
+
+    describe("getHttpUriForMxc", function() {
+        it("should do nothing to HTTP URLs when allowing direct links", function() {
+            const httpUrl = "http://example.com/image.jpeg";
+            expect(
+                ContentRepo.getHttpUriForMxc(
+                    baseUrl, httpUrl, undefined, undefined, undefined, true,
+                ),
+            ).toEqual(httpUrl);
+        });
+
+        it("should return the empty string HTTP URLs by default", function() {
+            const httpUrl = "http://example.com/image.jpeg";
+            expect(ContentRepo.getHttpUriForMxc(baseUrl, httpUrl)).toEqual("");
+        });
+
+        it("should return a download URL if no width/height/resize are specified",
+        function() {
+            const mxcUri = "mxc://server.name/resourceid";
+            expect(ContentRepo.getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
+                baseUrl + "/_matrix/media/v1/download/server.name/resourceid",
+            );
+        });
+
+        it("should return the empty string for null input", function() {
+            expect(ContentRepo.getHttpUriForMxc(null)).toEqual("");
+        });
+
+        it("should return a thumbnail URL if a width/height/resize is specified",
+        function() {
+            const mxcUri = "mxc://server.name/resourceid";
+            expect(ContentRepo.getHttpUriForMxc(baseUrl, mxcUri, 32, 64, "crop")).toEqual(
+                baseUrl + "/_matrix/media/v1/thumbnail/server.name/resourceid" +
+                "?width=32&height=64&method=crop",
+            );
+        });
+
+        it("should put fragments from mxc:// URIs after any query parameters",
+        function() {
+            const mxcUri = "mxc://server.name/resourceid#automade";
+            expect(ContentRepo.getHttpUriForMxc(baseUrl, mxcUri, 32)).toEqual(
+                baseUrl + "/_matrix/media/v1/thumbnail/server.name/resourceid" +
+                "?width=32#automade",
+            );
+        });
+
+        it("should put fragments from mxc:// URIs at the end of the HTTP URI",
+        function() {
+            const mxcUri = "mxc://server.name/resourceid#automade";
+            expect(ContentRepo.getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
+                baseUrl + "/_matrix/media/v1/download/server.name/resourceid#automade",
+            );
+        });
+    });
+
+    describe("getIdenticonUri", function() {
+        it("should do nothing for null input", function() {
+            expect(ContentRepo.getIdenticonUri(null)).toEqual(null);
+        });
+
+        it("should set w/h by default to 96", function() {
+            expect(ContentRepo.getIdenticonUri(baseUrl, "foobar")).toEqual(
+                baseUrl + "/_matrix/media/v1/identicon/foobar" +
+                "?width=96&height=96",
+            );
+        });
+
+        it("should be able to set custom w/h", function() {
+            expect(ContentRepo.getIdenticonUri(baseUrl, "foobar", 32, 64)).toEqual(
+                baseUrl + "/_matrix/media/v1/identicon/foobar" +
+                "?width=32&height=64",
+            );
+        });
+
+        it("should URL encode the identicon string", function() {
+            expect(ContentRepo.getIdenticonUri(baseUrl, "foo#bar", 32, 64)).toEqual(
+                baseUrl + "/_matrix/media/v1/identicon/foo%23bar" +
+                "?width=32&height=64",
+            );
+        });
+    });
+});
@@ -1,75 +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 { getHttpUriForMxc } from "../../src/content-repo";
-
-describe("ContentRepo", function() {
-    const baseUrl = "https://my.home.server";
-
-    describe("getHttpUriForMxc", function() {
-        it("should do nothing to HTTP URLs when allowing direct links", function() {
-            const httpUrl = "http://example.com/image.jpeg";
-            expect(
-                getHttpUriForMxc(
-                    baseUrl, httpUrl, undefined, undefined, undefined, true,
-                ),
-            ).toEqual(httpUrl);
-        });
-
-        it("should return the empty string HTTP URLs by default", function() {
-            const httpUrl = "http://example.com/image.jpeg";
-            expect(getHttpUriForMxc(baseUrl, httpUrl)).toEqual("");
-        });
-
-        it("should return a download URL if no width/height/resize are specified",
-            function() {
-                const mxcUri = "mxc://server.name/resourceid";
-                expect(getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
-                    baseUrl + "/_matrix/media/r0/download/server.name/resourceid",
-                );
-            });
-
-        it("should return the empty string for null input", function() {
-            expect(getHttpUriForMxc(null as any, '')).toEqual("");
-        });
-
-        it("should return a thumbnail URL if a width/height/resize is specified",
-            function() {
-                const mxcUri = "mxc://server.name/resourceid";
-                expect(getHttpUriForMxc(baseUrl, mxcUri, 32, 64, "crop")).toEqual(
-                    baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" +
-                "?width=32&height=64&method=crop",
-                );
-            });
-
-        it("should put fragments from mxc:// URIs after any query parameters",
-            function() {
-                const mxcUri = "mxc://server.name/resourceid#automade";
-                expect(getHttpUriForMxc(baseUrl, mxcUri, 32)).toEqual(
-                    baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" +
-                "?width=32#automade",
-                );
-            });
-
-        it("should put fragments from mxc:// URIs at the end of the HTTP URI",
-            function() {
-                const mxcUri = "mxc://server.name/resourceid#automade";
-                expect(getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
-                    baseUrl + "/_matrix/media/r0/download/server.name/resourceid#automade",
-                );
-            });
-    });
-});
@@ -0,0 +1,122 @@
+import 'source-map-support/register';
+
+import '../olm-loader';
+
+import Crypto from '../../lib/crypto';
+import expect from 'expect';
+
+import WebStorageSessionStore from '../../lib/store/session/webstorage';
+import MemoryCryptoStore from '../../lib/crypto/store/memory-crypto-store.js';
+import MockStorageApi from '../MockStorageApi';
+
+const EventEmitter = require("events").EventEmitter;
+
+const sdk = require("../..");
+
+const Olm = global.Olm;
+
+describe("Crypto", function() {
+    if (!sdk.CRYPTO_ENABLED) {
+        return;
+    }
+
+    beforeEach(function(done) {
+        Olm.init().then(done);
+    });
+
+    it("Crypto exposes the correct olm library version", function() {
+        expect(Crypto.getOlmVersion()[0]).toEqual(3);
+    });
+
+
+    describe('Session management', function() {
+        const otkResponse = {
+            one_time_keys: {
+                '@alice:home.server': {
+                    aliceDevice: {
+                        'signed_curve25519:FLIBBLE': {
+                            key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
+                            signatures: {
+                                '@alice:home.server': {
+                                    'ed25519:aliceDevice': 'totally a valid signature',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        let crypto;
+        let mockBaseApis;
+        let mockRoomList;
+
+        let fakeEmitter;
+
+        beforeEach(async function() {
+            const mockStorage = new MockStorageApi();
+            const sessionStore = new WebStorageSessionStore(mockStorage);
+            const cryptoStore = new MemoryCryptoStore(mockStorage);
+
+            cryptoStore.storeEndToEndDeviceData({
+                devices: {
+                    '@bob:home.server': {
+                        'BOBDEVICE': {
+                            keys: {
+                                'curve25519:BOBDEVICE': 'this is a key',
+                            },
+                        },
+                    },
+                },
+                trackingStatus: {},
+            });
+
+            mockBaseApis = {
+                sendToDevice: expect.createSpy(),
+                getKeyBackupVersion: expect.createSpy(),
+                isGuest: expect.createSpy(),
+            };
+            mockRoomList = {};
+
+            fakeEmitter = new EventEmitter();
+
+            crypto = new Crypto(
+                mockBaseApis,
+                sessionStore,
+                "@alice:home.server",
+                "FLIBBLE",
+                sessionStore,
+                cryptoStore,
+                mockRoomList,
+            );
+            crypto.registerEventHandlers(fakeEmitter);
+            await crypto.init();
+        });
+
+        afterEach(async function() {
+            await crypto.stop();
+        });
+
+        it("restarts wedged Olm sessions", async function() {
+            const prom = new Promise((resolve) => {
+                mockBaseApis.claimOneTimeKeys = function() {
+                    resolve();
+                    return otkResponse;
+                };
+            });
+
+            fakeEmitter.emit('toDeviceEvent', {
+                getType: expect.createSpy().andReturn('m.room.message'),
+                getContent: expect.createSpy().andReturn({
+                    msgtype: 'm.bad.encrypted',
+                }),
+                getWireContent: expect.createSpy().andReturn({
+                    algorithm: 'm.olm.v1.curve25519-aes-sha2',
+                    sender_key: 'this is a key',
+                }),
+                getSender: expect.createSpy().andReturn('@bob:home.server'),
+            });
+
+            await prom;
+        });
+    });
+});
@@ -1,260 +0,0 @@
-/*
-Copyright 2020 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import '../../olm-loader';
-import {
-    CrossSigningInfo,
-    createCryptoStoreCacheCallbacks,
-} from '../../../src/crypto/CrossSigning';
-import {
-    IndexedDBCryptoStore,
-} from '../../../src/crypto/store/indexeddb-crypto-store';
-import { MemoryCryptoStore } from '../../../src/crypto/store/memory-crypto-store';
-import 'fake-indexeddb/auto';
-import 'jest-localstorage-mock';
-import { OlmDevice } from "../../../src/crypto/OlmDevice";
-import { logger } from '../../../src/logger';
-
-const userId = "@alice:example.com";
-
-// Private key for tests only
-const testKey = new Uint8Array([
-    0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82,
-    0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef,
-    0xae, 0xb1, 0x05, 0xc1, 0xe7, 0x62, 0x78, 0xa6,
-    0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
-]);
-
-const types = [
-    { type: "master", shouldCache: true },
-    { type: "self_signing", shouldCache: true },
-    { type: "user_signing", shouldCache: true },
-    { type: "invalid", shouldCache: false },
-];
-
-const badKey = Uint8Array.from(testKey);
-badKey[0] ^= 1;
-
-const masterKeyPub = "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk";
-
-describe("CrossSigningInfo.getCrossSigningKey", function() {
-    if (!global.Olm) {
-        logger.warn('Not running megolm backup unit tests: libolm not present');
-        return;
-    }
-
-    beforeAll(function() {
-        return global.Olm.init();
-    });
-
-    it("should throw if no callback is provided", async () => {
-        const info = new CrossSigningInfo(userId);
-        await expect(info.getCrossSigningKey("master")).rejects.toThrow();
-    });
-
-    it.each(types)("should throw if the callback returns falsey",
-        async ({ type, shouldCache }) => {
-            const info = new CrossSigningInfo(userId, {
-                getCrossSigningKey: async () => false as unknown as Uint8Array,
-            });
-            await expect(info.getCrossSigningKey(type)).rejects.toThrow("falsey");
-        });
-
-    it("should throw if the expected key doesn't come back", async () => {
-        const info = new CrossSigningInfo(userId, {
-            getCrossSigningKey: async () => masterKeyPub as unknown as Uint8Array,
-        });
-        await expect(info.getCrossSigningKey("master", "")).rejects.toThrow();
-    });
-
-    it("should return a key from its callback", async () => {
-        const info = new CrossSigningInfo(userId, {
-            getCrossSigningKey: async () => testKey,
-        });
-        const [pubKey, pkSigning] = await info.getCrossSigningKey("master", masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-        // check that the pkSigning object corresponds to the pubKey
-        const signature = pkSigning.sign("message");
-        const util = new global.Olm.Utility();
-        try {
-            util.ed25519_verify(pubKey, "message", signature);
-        } finally {
-            util.free();
-        }
-    });
-
-    it.each(types)("should request a key from the cache callback (if set)" +
-                   " and does not call app if one is found" +
-                   " %o",
-    async ({ type, shouldCache }) => {
-        const getCrossSigningKey = jest.fn().mockImplementation(() => {
-            if (shouldCache) {
-                return Promise.reject(new Error("Regular callback called"));
-            } else {
-                return Promise.resolve(testKey);
-            }
-        });
-        const getCrossSigningKeyCache = jest.fn().mockResolvedValue(testKey);
-        const info = new CrossSigningInfo(
-            userId,
-            { getCrossSigningKey },
-            { getCrossSigningKeyCache },
-        );
-        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-        expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-        if (shouldCache) {
-            expect(getCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
-        }
-    });
-
-    it.each(types)("should store a key with the cache callback (if set)",
-        async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-            const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-            const info = new CrossSigningInfo(
-                userId,
-                { getCrossSigningKey },
-                { storeCrossSigningKeyCache },
-            );
-            const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-            expect(pubKey).toEqual(masterKeyPub);
-            expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(shouldCache ? 1 : 0);
-            if (shouldCache) {
-                expect(storeCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
-                expect(storeCrossSigningKeyCache.mock.calls[0][1]).toBe(testKey);
-            }
-        });
-
-    it.each(types)("does not store a bad key to the cache",
-        async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockResolvedValue(badKey);
-            const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-            const info = new CrossSigningInfo(
-                userId,
-                { getCrossSigningKey },
-                { storeCrossSigningKeyCache },
-            );
-            await expect(info.getCrossSigningKey(type, masterKeyPub)).rejects.toThrow();
-            expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(0);
-        });
-
-    it.each(types)("does not store a value to the cache if it came from the cache",
-        async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockImplementation(() => {
-                if (shouldCache) {
-                    return Promise.reject(new Error("Regular callback called"));
-                } else {
-                    return Promise.resolve(testKey);
-                }
-            });
-            const getCrossSigningKeyCache = jest.fn().mockResolvedValue(testKey);
-            const storeCrossSigningKeyCache = jest.fn().mockRejectedValue(
-                new Error("Tried to store a value from cache"),
-            );
-            const info = new CrossSigningInfo(
-                userId,
-                { getCrossSigningKey },
-                { getCrossSigningKeyCache, storeCrossSigningKeyCache },
-            );
-            expect(storeCrossSigningKeyCache.mock.calls.length).toBe(0);
-            const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-            expect(pubKey).toEqual(masterKeyPub);
-        });
-
-    it.each(types)("requests a key from the cache callback (if set) and then calls app" +
-        " if one is not found", async ({ type, shouldCache }) => {
-        const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-        const getCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-        const storeCrossSigningKeyCache = jest.fn();
-        const info = new CrossSigningInfo(
-            userId,
-            { getCrossSigningKey },
-            { getCrossSigningKeyCache, storeCrossSigningKeyCache },
-        );
-        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-        expect(getCrossSigningKey.mock.calls.length).toBe(1);
-        expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-
-        /* Also expect that the cache gets updated */
-        expect(storeCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-    });
-
-    it.each(types)("requests a key from the cache callback (if set) and then" +
-        " calls app if that key doesn't match", async ({ type, shouldCache }) => {
-        const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-        const getCrossSigningKeyCache = jest.fn().mockResolvedValue(badKey);
-        const storeCrossSigningKeyCache = jest.fn();
-        const info = new CrossSigningInfo(
-            userId,
-            { getCrossSigningKey },
-            { getCrossSigningKeyCache, storeCrossSigningKeyCache },
-        );
-        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-        expect(getCrossSigningKey.mock.calls.length).toBe(1);
-        expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-
-        /* Also expect that the cache gets updated */
-        expect(storeCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-    });
-});
-
-/*
- * Note that MemoryStore is weird.  It's only used for testing - as far as I can tell,
- * it's not possible to get one in normal execution unless you hack as we do here.
- */
-describe.each([
-    ["IndexedDBCryptoStore",
-        () => new IndexedDBCryptoStore(global.indexedDB, "tests")],
-    ["LocalStorageCryptoStore",
-        () => new IndexedDBCryptoStore(undefined!, "tests")],
-    ["MemoryCryptoStore", () => {
-        const store = new IndexedDBCryptoStore(undefined!, "tests");
-        // @ts-ignore set private properties
-        store._backend = new MemoryCryptoStore();
-        // @ts-ignore
-        store._backendPromise = Promise.resolve(store._backend);
-        return store;
-    }],
-])("CrossSigning > createCryptoStoreCacheCallbacks [%s]", function(name, dbFactory) {
-    let store;
-
-    beforeAll(() => {
-        store = dbFactory();
-    });
-
-    beforeEach(async () => {
-        await store.deleteAllData();
-    });
-
-    it("should cache data to the store and retrieve it", async () => {
-        await store.startup();
-        const olmDevice = new OlmDevice(store);
-        const { getCrossSigningKeyCache, storeCrossSigningKeyCache } =
-              createCryptoStoreCacheCallbacks(store, olmDevice);
-        await storeCrossSigningKeyCache!("self_signing", testKey);
-
-        // If we've not saved anything, don't expect anything
-        // Definitely don't accidentally return the wrong key for the type
-        const nokey = await getCrossSigningKeyCache!("self", "");
-        expect(nokey).toBeNull();
-
-        const key = await getCrossSigningKeyCache!("self_signing", "");
-        expect(new Uint8Array(key!)).toEqual(testKey);
-    });
-});
@@ -1,7 +1,6 @@
 /*
 Copyright 2017 Vector Creations Ltd
-Copyright 2018, 2019 New Vector Ltd
-Copyright 2019, 2022 The Matrix.org Foundation C.I.C.
+Copyright 2018 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.
@@ -16,14 +15,17 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { logger } from "../../../src/logger";
-import * as utils from "../../../src/utils";
-import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
-import { DeviceList } from "../../../src/crypto/DeviceList";
-import { IDownloadKeyResult, MatrixClient } from "../../../src";
-import { OlmDevice } from "../../../src/crypto/OlmDevice";
+import DeviceList from '../../../lib/crypto/DeviceList';
+import MockStorageApi from '../../MockStorageApi';
+import WebStorageSessionStore from '../../../lib/store/session/webstorage';
+import MemoryCryptoStore from '../../../lib/crypto/store/memory-crypto-store.js';
+import testUtils from '../../test-utils';
+import utils from '../../../lib/utils';

-const signedDeviceList: IDownloadKeyResult = {
+import expect from 'expect';
+import Promise from 'bluebird';
+
+const signedDeviceList = {
    "failures": {},
    "device_keys": {
        "@test1:sw1v.org": {
@@ -47,41 +49,7 @@ const signedDeviceList: IDownloadKeyResult = {
                    "m.megolm.v1.aes-sha2",
                ],
                "device_id": "HGKAWHRVJQ",
-                "unsigned": {
-                    "device_display_name": "",
-                },
-            },
-        },
-    },
-};
-
-const signedDeviceList2: IDownloadKeyResult = {
-    "failures": {},
-    "device_keys": {
-        "@test2:sw1v.org": {
-            "QJVRHWAKGH": {
-                "signatures": {
-                    "@test2:sw1v.org": {
-                        "ed25519:QJVRHWAKGH":
-                            "w1xxdLe1iIqzEFHLRVYQeuiM6t2N2ZRiI8s5nDKxf054BP8" +
-                            "1CPEX/AQXh5BhkKAVMlKnwg4T9zU1/wBALeajk3",
-                    },
-                },
-                "user_id": "@test2:sw1v.org",
-                "keys": {
-                    "ed25519:QJVRHWAKGH":
-                        "Ig0/C6T+bBII1l2By2Wnnvtjp1nm/iXBlLU5/QESFXL",
-                    "curve25519:QJVRHWAKGH":
-                        "YR3eQnUvTQzGlWih4rsmJkKxpDxzgkgIgsBd1DEZIbm",
-                },
-                "algorithms": [
-                    "m.olm.v1.curve25519-aes-sha2",
-                    "m.megolm.v1.aes-sha2",
-                ],
-                "device_id": "QJVRHWAKGH",
-                "unsigned": {
-                    "device_display_name": "",
-                },
+                "unsigned": {},
            },
        },
    },
@@ -89,13 +57,18 @@ const signedDeviceList2: IDownloadKeyResult = {

 describe('DeviceList', function() {
    let downloadSpy;
+    let sessionStore;
    let cryptoStore;
-    let deviceLists: DeviceList[] = [];
+    let deviceLists = [];

    beforeEach(function() {
+        testUtils.beforeEach(this); // eslint-disable-line no-invalid-this
+
        deviceLists = [];

-        downloadSpy = jest.fn();
+        downloadSpy = expect.createSpy();
+        const mockStorage = new MockStorageApi();
+        sessionStore = new WebStorageSessionStore(mockStorage);
        cryptoStore = new MemoryCryptoStore();
    });

@@ -105,16 +78,14 @@ describe('DeviceList', function() {
        }
    });

-    function createTestDeviceList(keyDownloadChunkSize = 250) {
+    function createTestDeviceList() {
        const baseApis = {
            downloadKeysForUsers: downloadSpy,
-            getUserId: () => '@test1:sw1v.org',
-            deviceId: 'HGKAWHRVJQ',
-        } as unknown as MatrixClient;
+        };
        const mockOlm = {
            verifySignature: function(key, message, signature) {},
-        } as unknown as OlmDevice;
-        const dl = new DeviceList(baseApis, cryptoStore, mockOlm, keyDownloadChunkSize);
+        };
+        const dl = new DeviceList(baseApis, cryptoStore, sessionStore, mockOlm);
        deviceLists.push(dl);
        return dl;
    }
@@ -124,8 +95,8 @@ describe('DeviceList', function() {

        dl.startTrackingDeviceList('@test1:sw1v.org');

-        const queryDefer1 = utils.defer<IDownloadKeyResult>();
-        downloadSpy.mockReturnValue(queryDefer1.promise);
+        const queryDefer1 = Promise.defer();
+        downloadSpy.andReturn(queryDefer1.promise);

        const prom1 = dl.refreshOutdatedDeviceLists();
        expect(downloadSpy).toHaveBeenCalledWith(['@test1:sw1v.org'], {});
@@ -134,7 +105,6 @@ describe('DeviceList', function() {
        return prom1.then(() => {
            const storedKeys = dl.getRawStoredDevicesForUser('@test1:sw1v.org');
            expect(Object.keys(storedKeys)).toEqual(['HGKAWHRVJQ']);
-            dl.stop();
        });
    });

@@ -144,16 +114,16 @@ describe('DeviceList', function() {

        dl.startTrackingDeviceList('@test1:sw1v.org');

-        const queryDefer1 = utils.defer<IDownloadKeyResult>();
-        downloadSpy.mockReturnValue(queryDefer1.promise);
+        const queryDefer1 = Promise.defer();
+        downloadSpy.andReturn(queryDefer1.promise);

        const prom1 = dl.refreshOutdatedDeviceLists();
        expect(downloadSpy).toHaveBeenCalledWith(['@test1:sw1v.org'], {});
-        downloadSpy.mockReset();
+        downloadSpy.reset();

        // outdated notif arrives while the request is in flight.
-        const queryDefer2 = utils.defer();
-        downloadSpy.mockReturnValue(queryDefer2.promise);
+        const queryDefer2 = Promise.defer();
+        downloadSpy.andReturn(queryDefer2.promise);

        dl.invalidateUserDeviceList('@test1:sw1v.org');
        dl.refreshOutdatedDeviceLists();
@@ -161,7 +131,6 @@ describe('DeviceList', function() {
        dl.saveIfDirty().then(() => {
            // the first request completes
            queryDefer1.resolve({
-                failures: {},
                device_keys: {
                    '@test1:sw1v.org': {},
                },
@@ -170,15 +139,14 @@ describe('DeviceList', function() {
        }).then(() => {
            // uh-oh; user restarts before second request completes. The new instance
            // should know we never got a complete device list.
-            logger.log("Creating new devicelist to simulate app reload");
-            downloadSpy.mockReset();
+            console.log("Creating new devicelist to simulate app reload");
+            downloadSpy.reset();
            const dl2 = createTestDeviceList();
-            const queryDefer3 = utils.defer<IDownloadKeyResult>();
-            downloadSpy.mockReturnValue(queryDefer3.promise);
+            const queryDefer3 = Promise.defer();
+            downloadSpy.andReturn(queryDefer3.promise);

            const prom3 = dl2.refreshOutdatedDeviceLists();
            expect(downloadSpy).toHaveBeenCalledWith(['@test1:sw1v.org'], {});
-            dl2.stop();

            queryDefer3.resolve(utils.deepCopy(signedDeviceList));

@@ -187,34 +155,6 @@ describe('DeviceList', function() {
        }).then(() => {
            const storedKeys = dl.getRawStoredDevicesForUser('@test1:sw1v.org');
            expect(Object.keys(storedKeys)).toEqual(['HGKAWHRVJQ']);
-            dl.stop();
-        });
-    });
-
-    it("should download device keys in batches", function() {
-        const dl = createTestDeviceList(1);
-
-        dl.startTrackingDeviceList('@test1:sw1v.org');
-        dl.startTrackingDeviceList('@test2:sw1v.org');
-
-        const queryDefer1 = utils.defer<IDownloadKeyResult>();
-        downloadSpy.mockReturnValueOnce(queryDefer1.promise);
-        const queryDefer2 = utils.defer<IDownloadKeyResult>();
-        downloadSpy.mockReturnValueOnce(queryDefer2.promise);
-
-        const prom1 = dl.refreshOutdatedDeviceLists();
-        expect(downloadSpy).toBeCalledTimes(2);
-        expect(downloadSpy).toHaveBeenNthCalledWith(1, ['@test1:sw1v.org'], {});
-        expect(downloadSpy).toHaveBeenNthCalledWith(2, ['@test2:sw1v.org'], {});
-        queryDefer1.resolve(utils.deepCopy(signedDeviceList));
-        queryDefer2.resolve(utils.deepCopy(signedDeviceList2));
-
-        return prom1.then(() => {
-            const storedKeys1 = dl.getRawStoredDevicesForUser('@test1:sw1v.org');
-            expect(Object.keys(storedKeys1)).toEqual(['HGKAWHRVJQ']);
-            const storedKeys2 = dl.getRawStoredDevicesForUser('@test2:sw1v.org');
-            expect(Object.keys(storedKeys2)).toEqual(['QJVRHWAKGH']);
-            dl.stop();
        });
    });
 });
@@ -0,0 +1,352 @@
+import '../../../olm-loader';
+
+import expect from 'expect';
+import Promise from 'bluebird';
+
+import sdk from '../../../..';
+import algorithms from '../../../../lib/crypto/algorithms';
+import WebStorageSessionStore from '../../../../lib/store/session/webstorage';
+import MemoryCryptoStore from '../../../../lib/crypto/store/memory-crypto-store.js';
+import MockStorageApi from '../../../MockStorageApi';
+import testUtils from '../../../test-utils';
+import OlmDevice from '../../../../lib/crypto/OlmDevice';
+import Crypto from '../../../../lib/crypto';
+
+const MatrixEvent = sdk.MatrixEvent;
+const MegolmDecryption = algorithms.DECRYPTION_CLASSES['m.megolm.v1.aes-sha2'];
+const MegolmEncryption = algorithms.ENCRYPTION_CLASSES['m.megolm.v1.aes-sha2'];
+
+const ROOM_ID = '!ROOM:ID';
+
+const Olm = global.Olm;
+
+describe("MegolmDecryption", function() {
+    if (!global.Olm) {
+        console.warn('Not running megolm unit tests: libolm not present');
+        return;
+    }
+
+    let megolmDecryption;
+    let mockOlmLib;
+    let mockCrypto;
+    let mockBaseApis;
+
+    beforeEach(async function() {
+        testUtils.beforeEach(this); // eslint-disable-line no-invalid-this
+
+        await Olm.init();
+
+        mockCrypto = testUtils.mock(Crypto, 'Crypto');
+        mockBaseApis = {};
+
+        const mockStorage = new MockStorageApi();
+        const sessionStore = new WebStorageSessionStore(mockStorage);
+        const cryptoStore = new MemoryCryptoStore(mockStorage);
+
+        const olmDevice = new OlmDevice(sessionStore, cryptoStore);
+
+        megolmDecryption = new MegolmDecryption({
+            userId: '@user:id',
+            crypto: mockCrypto,
+            olmDevice: olmDevice,
+            baseApis: mockBaseApis,
+            roomId: ROOM_ID,
+        });
+
+
+        // we stub out the olm encryption bits
+        mockOlmLib = {};
+        mockOlmLib.ensureOlmSessionsForDevices = expect.createSpy();
+        mockOlmLib.encryptMessageForDevice =
+            expect.createSpy().andReturn(Promise.resolve());
+        megolmDecryption.olmlib = mockOlmLib;
+    });
+
+    describe('receives some keys:', function() {
+        let groupSession;
+        beforeEach(async function() {
+            groupSession = new global.Olm.OutboundGroupSession();
+            groupSession.create();
+
+            // construct a fake decrypted key event via the use of a mocked
+            // 'crypto' implementation.
+            const event = new MatrixEvent({
+                type: 'm.room.encrypted',
+            });
+            const decryptedData = {
+                clearEvent: {
+                    type: 'm.room_key',
+                    content: {
+                        algorithm: 'm.megolm.v1.aes-sha2',
+                        room_id: ROOM_ID,
+                        session_id: groupSession.session_id(),
+                        session_key: groupSession.session_key(),
+                    },
+                },
+                senderCurve25519Key: "SENDER_CURVE25519",
+                claimedEd25519Key: "SENDER_ED25519",
+            };
+
+            const mockCrypto = {
+                decryptEvent: function() {
+                    return Promise.resolve(decryptedData);
+                },
+            };
+
+            await event.attemptDecryption(mockCrypto).then(() => {
+                megolmDecryption.onRoomKeyEvent(event);
+            });
+        });
+
+        it('can decrypt an event', function() {
+            const event = new MatrixEvent({
+                type: 'm.room.encrypted',
+                room_id: ROOM_ID,
+                content: {
+                    algorithm: 'm.megolm.v1.aes-sha2',
+                    sender_key: "SENDER_CURVE25519",
+                    session_id: groupSession.session_id(),
+                    ciphertext: groupSession.encrypt(JSON.stringify({
+                        room_id: ROOM_ID,
+                        content: 'testytest',
+                    })),
+                },
+            });
+
+            return megolmDecryption.decryptEvent(event).then((res) => {
+                expect(res.clearEvent.content).toEqual('testytest');
+            });
+        });
+
+        it('can respond to a key request event', function() {
+            const keyRequest = {
+                userId: '@alice:foo',
+                deviceId: 'alidevice',
+                requestBody: {
+                    room_id: ROOM_ID,
+                    sender_key: "SENDER_CURVE25519",
+                    session_id: groupSession.session_id(),
+                },
+            };
+
+            return megolmDecryption.hasKeysForKeyRequest(
+                keyRequest,
+            ).then((hasKeys) => {
+                expect(hasKeys).toBe(true);
+
+                // set up some pre-conditions for the share call
+                const deviceInfo = {};
+                mockCrypto.getStoredDevice.andReturn(deviceInfo);
+
+                mockOlmLib.ensureOlmSessionsForDevices.andReturn(
+                    Promise.resolve({'@alice:foo': {'alidevice': {
+                        sessionId: 'alisession',
+                    }}}),
+                );
+
+                const awaitEncryptForDevice = new Promise((res, rej) => {
+                    mockOlmLib.encryptMessageForDevice.andCall(() => {
+                        res();
+                        return Promise.resolve();
+                    });
+                });
+
+                mockBaseApis.sendToDevice = expect.createSpy();
+
+                // do the share
+                megolmDecryption.shareKeysWithDevice(keyRequest);
+
+                // it's asynchronous, so we have to wait a bit
+                return awaitEncryptForDevice;
+            }).then(() => {
+                // check that it called encryptMessageForDevice with
+                // appropriate args.
+                expect(mockOlmLib.encryptMessageForDevice.calls.length)
+                    .toEqual(1);
+
+                const call = mockOlmLib.encryptMessageForDevice.calls[0];
+                const payload = call.arguments[6];
+
+                expect(payload.type).toEqual("m.forwarded_room_key");
+                expect(payload.content).toInclude({
+                    sender_key: "SENDER_CURVE25519",
+                    sender_claimed_ed25519_key: "SENDER_ED25519",
+                    session_id: groupSession.session_id(),
+                    chain_index: 0,
+                    forwarding_curve25519_key_chain: [],
+                });
+                expect(payload.content.session_key).toExist();
+            });
+        });
+
+        it("can detect replay attacks", function() {
+            // trying to decrypt two different messages (marked by different
+            // event IDs or timestamps) using the same (sender key, session id,
+            // message index) triple should result in an exception being thrown
+            // as it should be detected as a replay attack.
+            const sessionId = groupSession.session_id();
+            const cipherText = groupSession.encrypt(JSON.stringify({
+                room_id: ROOM_ID,
+                content: 'testytest',
+            }));
+            const event1 = new MatrixEvent({
+                type: 'm.room.encrypted',
+                room_id: ROOM_ID,
+                content: {
+                    algorithm: 'm.megolm.v1.aes-sha2',
+                    sender_key: "SENDER_CURVE25519",
+                    session_id: sessionId,
+                    ciphertext: cipherText,
+                },
+                event_id: "$event1",
+                origin_server_ts: 1507753886000,
+            });
+
+            const successHandler = expect.createSpy();
+            const failureHandler = expect.createSpy()
+                .andCall((err) => {
+                    expect(err.toString()).toMatch(
+                        /Duplicate message index, possible replay attack/,
+                    );
+                });
+
+            return megolmDecryption.decryptEvent(event1).then((res) => {
+                const event2 = new MatrixEvent({
+                    type: 'm.room.encrypted',
+                    room_id: ROOM_ID,
+                    content: {
+                        algorithm: 'm.megolm.v1.aes-sha2',
+                        sender_key: "SENDER_CURVE25519",
+                        session_id: sessionId,
+                        ciphertext: cipherText,
+                    },
+                    event_id: "$event2",
+                    origin_server_ts: 1507754149000,
+                });
+
+                return megolmDecryption.decryptEvent(event2);
+            }).then(
+                successHandler,
+                failureHandler,
+            ).then(() => {
+                expect(successHandler).toNotHaveBeenCalled();
+                expect(failureHandler).toHaveBeenCalled();
+            });
+        });
+
+        it("allows re-decryption of the same event", function() {
+            // in contrast with the previous test, if the event ID and
+            // timestamp are the same, then it should not be considered a
+            // replay attack
+            const sessionId = groupSession.session_id();
+            const cipherText = groupSession.encrypt(JSON.stringify({
+                room_id: ROOM_ID,
+                content: 'testytest',
+            }));
+            const event = new MatrixEvent({
+                type: 'm.room.encrypted',
+                room_id: ROOM_ID,
+                content: {
+                    algorithm: 'm.megolm.v1.aes-sha2',
+                    sender_key: "SENDER_CURVE25519",
+                    session_id: sessionId,
+                    ciphertext: cipherText,
+                },
+                event_id: "$event1",
+                origin_server_ts: 1507753886000,
+            });
+
+            return megolmDecryption.decryptEvent(event).then((res) => {
+                return megolmDecryption.decryptEvent(event);
+                // test is successful if no exception is thrown
+            });
+        });
+
+        it("re-uses sessions for sequential messages", async function() {
+            const mockStorage = new MockStorageApi();
+            const sessionStore = new WebStorageSessionStore(mockStorage);
+            const cryptoStore = new MemoryCryptoStore(mockStorage);
+
+            const olmDevice = new OlmDevice(sessionStore, cryptoStore);
+            olmDevice.verifySignature = expect.createSpy();
+            await olmDevice.init();
+
+            mockBaseApis.claimOneTimeKeys = expect.createSpy().andReturn(Promise.resolve({
+                one_time_keys: {
+                    '@alice:home.server': {
+                        aliceDevice: {
+                            'signed_curve25519:flooble': {
+                                key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
+                                signatures: {
+                                    '@alice:home.server': {
+                                        'ed25519:aliceDevice': 'totally valid',
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            }));
+            mockBaseApis.sendToDevice = expect.createSpy().andReturn(Promise.resolve());
+
+            mockCrypto.downloadKeys.andReturn(Promise.resolve({
+                '@alice:home.server': {
+                    aliceDevice: {
+                        deviceId: 'aliceDevice',
+                        isBlocked: expect.createSpy().andReturn(false),
+                        isUnverified: expect.createSpy().andReturn(false),
+                        getIdentityKey: expect.createSpy().andReturn(
+                            'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
+                        ),
+                        getFingerprint: expect.createSpy().andReturn(''),
+                    },
+                },
+            }));
+
+            const megolmEncryption = new MegolmEncryption({
+                userId: '@user:id',
+                crypto: mockCrypto,
+                olmDevice: olmDevice,
+                baseApis: mockBaseApis,
+                roomId: ROOM_ID,
+                config: {
+                    rotation_period_ms: 9999999999999,
+                },
+            });
+            const mockRoom = {
+                getEncryptionTargetMembers: expect.createSpy().andReturn(
+                    [{userId: "@alice:home.server"}],
+                ),
+                getBlacklistUnverifiedDevices: expect.createSpy().andReturn(false),
+            };
+            const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                body: "Some text",
+            });
+            expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
+
+            // this should have claimed a key for alice as it's starting a new session
+            expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalled(
+                [['@alice:home.server', 'aliceDevice']], 'signed_curve25519',
+            );
+            expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
+                ['@alice:home.server'], false,
+            );
+            expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
+            expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalled(
+                [['@alice:home.server', 'aliceDevice']], 'signed_curve25519',
+            );
+
+            mockBaseApis.claimOneTimeKeys.reset();
+
+            const ct2 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                body: "Some more text",
+            });
+
+            // this should *not* have claimed a key as it should be using the same session
+            expect(mockBaseApis.claimOneTimeKeys).toNotHaveBeenCalled();
+
+            // likewise they should show the same session ID
+            expect(ct2.session_id).toEqual(ct1.session_id);
+        });
+    });
+});
@@ -1,991 +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 { mocked, MockedObject } from 'jest-mock';
-
-import '../../../olm-loader';
-import * as algorithms from "../../../../src/crypto/algorithms";
-import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
-import * as testUtils from "../../../test-utils/test-utils";
-import { OlmDevice } from "../../../../src/crypto/OlmDevice";
-import { Crypto, IncomingRoomKeyRequest } from "../../../../src/crypto";
-import { logger } from "../../../../src/logger";
-import { MatrixEvent } from "../../../../src/models/event";
-import { TestClient } from "../../../TestClient";
-import { Room } from "../../../../src/models/room";
-import * as olmlib from "../../../../src/crypto/olmlib";
-import { TypedEventEmitter } from '../../../../src/models/typed-event-emitter';
-import { ClientEvent, MatrixClient, RoomMember } from '../../../../src';
-import { DeviceInfo, IDevice } from '../../../../src/crypto/deviceinfo';
-import { DeviceTrustLevel } from '../../../../src/crypto/CrossSigning';
-
-const MegolmDecryption = algorithms.DECRYPTION_CLASSES.get('m.megolm.v1.aes-sha2')!;
-const MegolmEncryption = algorithms.ENCRYPTION_CLASSES.get('m.megolm.v1.aes-sha2')!;
-
-const ROOM_ID = '!ROOM:ID';
-
-const Olm = global.Olm;
-
-describe("MegolmDecryption", function() {
-    if (!global.Olm) {
-        logger.warn('Not running megolm unit tests: libolm not present');
-        return;
-    }
-
-    beforeAll(function() {
-        return Olm.init();
-    });
-
-    let megolmDecryption: algorithms.DecryptionAlgorithm;
-    let mockOlmLib: MockedObject<typeof olmlib>;
-    let mockCrypto: MockedObject<Crypto>;
-    let mockBaseApis: MockedObject<MatrixClient>;
-
-    beforeEach(async function() {
-        mockCrypto = testUtils.mock(Crypto, 'Crypto') as MockedObject<Crypto>;
-        mockBaseApis = {
-            claimOneTimeKeys: jest.fn(),
-            sendToDevice: jest.fn(),
-            queueToDevice: jest.fn(),
-        } as unknown as MockedObject<MatrixClient>;
-
-        const cryptoStore = new MemoryCryptoStore();
-
-        const olmDevice = new OlmDevice(cryptoStore);
-
-        megolmDecryption = new MegolmDecryption({
-            userId: '@user:id',
-            crypto: mockCrypto,
-            olmDevice: olmDevice,
-            baseApis: mockBaseApis,
-            roomId: ROOM_ID,
-        });
-
-        // we stub out the olm encryption bits
-        mockOlmLib = {
-            encryptMessageForDevice: jest.fn().mockResolvedValue(undefined),
-            ensureOlmSessionsForDevices: jest.fn(),
-        } as unknown as MockedObject<typeof olmlib>;
-
-        // @ts-ignore illegal assignment that makes these tests work :/
-        megolmDecryption.olmlib = mockOlmLib;
-
-        jest.clearAllMocks();
-    });
-
-    describe('receives some keys:', function() {
-        let groupSession;
-        beforeEach(async function() {
-            groupSession = new global.Olm.OutboundGroupSession();
-            groupSession.create();
-
-            // construct a fake decrypted key event via the use of a mocked
-            // 'crypto' implementation.
-            const event = new MatrixEvent({
-                type: 'm.room.encrypted',
-            });
-            const decryptedData = {
-                clearEvent: {
-                    type: 'm.room_key',
-                    content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
-                        room_id: ROOM_ID,
-                        session_id: groupSession.session_id(),
-                        session_key: groupSession.session_key(),
-                    },
-                },
-                senderCurve25519Key: "SENDER_CURVE25519",
-                claimedEd25519Key: "SENDER_ED25519",
-            };
-            event.getWireType = () => "m.room.encrypted";
-            event.getWireContent = () => {
-                return {
-                    algorithm: "m.olm.v1.curve25519-aes-sha2",
-                };
-            };
-
-            const mockCrypto = {
-                decryptEvent: function() {
-                    return Promise.resolve(decryptedData);
-                },
-            } as unknown as Crypto;
-
-            await event.attemptDecryption(mockCrypto).then(() => {
-                megolmDecryption.onRoomKeyEvent(event);
-            });
-        });
-
-        it('can decrypt an event', function() {
-            const event = new MatrixEvent({
-                type: 'm.room.encrypted',
-                room_id: ROOM_ID,
-                content: {
-                    algorithm: 'm.megolm.v1.aes-sha2',
-                    sender_key: "SENDER_CURVE25519",
-                    session_id: groupSession.session_id(),
-                    ciphertext: groupSession.encrypt(JSON.stringify({
-                        room_id: ROOM_ID,
-                        content: 'testytest',
-                    })),
-                },
-            });
-
-            return megolmDecryption.decryptEvent(event).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-            });
-        });
-
-        it('can respond to a key request event', function() {
-            const keyRequest: IncomingRoomKeyRequest = {
-                requestId: '123',
-                share: jest.fn(),
-                userId: '@alice:foo',
-                deviceId: 'alidevice',
-                requestBody: {
-                    algorithm: '',
-                    room_id: ROOM_ID,
-                    sender_key: "SENDER_CURVE25519",
-                    session_id: groupSession.session_id(),
-                },
-            };
-
-            return megolmDecryption.hasKeysForKeyRequest(
-                keyRequest,
-            ).then((hasKeys) => {
-                expect(hasKeys).toBe(true);
-
-                // set up some pre-conditions for the share call
-                const deviceInfo = {} as DeviceInfo;
-                mockCrypto.getStoredDevice.mockReturnValue(deviceInfo);
-
-                mockOlmLib.ensureOlmSessionsForDevices.mockResolvedValue({
-                    '@alice:foo': { 'alidevice': {
-                        sessionId: 'alisession',
-                        device: new DeviceInfo('alidevice'),
-                    } },
-                });
-
-                const awaitEncryptForDevice = new Promise<void>((res, rej) => {
-                    mockOlmLib.encryptMessageForDevice.mockImplementation(() => {
-                        res();
-                        return Promise.resolve();
-                    });
-                });
-
-                mockBaseApis.sendToDevice.mockReset();
-                mockBaseApis.queueToDevice.mockReset();
-
-                // do the share
-                megolmDecryption.shareKeysWithDevice(keyRequest);
-
-                // it's asynchronous, so we have to wait a bit
-                return awaitEncryptForDevice;
-            }).then(() => {
-                // check that it called encryptMessageForDevice with
-                // appropriate args.
-                expect(mockOlmLib.encryptMessageForDevice).toBeCalledTimes(1);
-
-                const call = mockOlmLib.encryptMessageForDevice.mock.calls[0];
-                const payload = call[6];
-
-                expect(payload.type).toEqual("m.forwarded_room_key");
-                expect(payload.content).toMatchObject({
-                    sender_key: "SENDER_CURVE25519",
-                    sender_claimed_ed25519_key: "SENDER_ED25519",
-                    session_id: groupSession.session_id(),
-                    chain_index: 0,
-                    forwarding_curve25519_key_chain: [],
-                });
-                expect(payload.content.session_key).toBeDefined();
-            });
-        });
-
-        it("can detect replay attacks", function() {
-            // trying to decrypt two different messages (marked by different
-            // event IDs or timestamps) using the same (sender key, session id,
-            // message index) triple should result in an exception being thrown
-            // as it should be detected as a replay attack.
-            const sessionId = groupSession.session_id();
-            const cipherText = groupSession.encrypt(JSON.stringify({
-                room_id: ROOM_ID,
-                content: 'testytest',
-            }));
-            const event1 = new MatrixEvent({
-                type: 'm.room.encrypted',
-                room_id: ROOM_ID,
-                content: {
-                    algorithm: 'm.megolm.v1.aes-sha2',
-                    sender_key: "SENDER_CURVE25519",
-                    session_id: sessionId,
-                    ciphertext: cipherText,
-                },
-                event_id: "$event1",
-                origin_server_ts: 1507753886000,
-            });
-
-            const successHandler = jest.fn();
-            const failureHandler = jest.fn((err) => {
-                expect(err.toString()).toMatch(
-                    /Duplicate message index, possible replay attack/,
-                );
-            });
-
-            return megolmDecryption.decryptEvent(event1).then((res) => {
-                const event2 = new MatrixEvent({
-                    type: 'm.room.encrypted',
-                    room_id: ROOM_ID,
-                    content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
-                        sender_key: "SENDER_CURVE25519",
-                        session_id: sessionId,
-                        ciphertext: cipherText,
-                    },
-                    event_id: "$event2",
-                    origin_server_ts: 1507754149000,
-                });
-
-                return megolmDecryption.decryptEvent(event2);
-            }).then(
-                successHandler,
-                failureHandler,
-            ).then(() => {
-                expect(successHandler).not.toHaveBeenCalled();
-                expect(failureHandler).toHaveBeenCalled();
-            });
-        });
-
-        it("allows re-decryption of the same event", function() {
-            // in contrast with the previous test, if the event ID and
-            // timestamp are the same, then it should not be considered a
-            // replay attack
-            const sessionId = groupSession.session_id();
-            const cipherText = groupSession.encrypt(JSON.stringify({
-                room_id: ROOM_ID,
-                content: 'testytest',
-            }));
-            const event = new MatrixEvent({
-                type: 'm.room.encrypted',
-                room_id: ROOM_ID,
-                content: {
-                    algorithm: 'm.megolm.v1.aes-sha2',
-                    sender_key: "SENDER_CURVE25519",
-                    session_id: sessionId,
-                    ciphertext: cipherText,
-                },
-                event_id: "$event1",
-                origin_server_ts: 1507753886000,
-            });
-
-            return megolmDecryption.decryptEvent(event).then((res) => {
-                return megolmDecryption.decryptEvent(event);
-                // test is successful if no exception is thrown
-            });
-        });
-
-        describe("session reuse and key reshares", () => {
-            const rotationPeriodMs = 999 * 24 * 60 * 60 * 1000; // 999 days, so we don't have to deal with it
-
-            let megolmEncryption;
-            let aliceDeviceInfo;
-            let mockRoom;
-            let olmDevice;
-
-            beforeEach(async () => {
-                // @ts-ignore assigning to readonly prop
-                mockCrypto.backupManager = {
-                    backupGroupSession: () => {},
-                };
-                const cryptoStore = new MemoryCryptoStore();
-
-                olmDevice = new OlmDevice(cryptoStore);
-                olmDevice.verifySignature = jest.fn();
-                await olmDevice.init();
-
-                mockBaseApis.claimOneTimeKeys.mockResolvedValue({
-                    failures: {},
-                    one_time_keys: {
-                        '@alice:home.server': {
-                            aliceDevice: {
-                                'signed_curve25519:flooble': {
-                                    key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
-                                    signatures: {
-                                        '@alice:home.server': {
-                                            'ed25519:aliceDevice': 'totally valid',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                });
-                mockBaseApis.sendToDevice.mockResolvedValue({});
-                mockBaseApis.queueToDevice.mockResolvedValue(undefined);
-
-                aliceDeviceInfo = {
-                    deviceId: 'aliceDevice',
-                    isBlocked: jest.fn().mockReturnValue(false),
-                    isUnverified: jest.fn().mockReturnValue(false),
-                    getIdentityKey: jest.fn().mockReturnValue(
-                        'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
-                    ),
-                    getFingerprint: jest.fn().mockReturnValue(''),
-                };
-
-                mockCrypto.downloadKeys.mockReturnValue(Promise.resolve({
-                    '@alice:home.server': {
-                        aliceDevice: aliceDeviceInfo,
-                    },
-                }));
-
-                mockCrypto.checkDeviceTrust.mockReturnValue({
-                    isVerified: () => false,
-                } as DeviceTrustLevel);
-
-                megolmEncryption = new MegolmEncryption({
-                    userId: '@user:id',
-                    deviceId: '12345',
-                    crypto: mockCrypto,
-                    olmDevice: olmDevice,
-                    baseApis: mockBaseApis,
-                    roomId: ROOM_ID,
-                    config: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
-                        rotation_period_ms: rotationPeriodMs,
-                    },
-                });
-
-                // Splice the real method onto the mock object as megolm uses this method
-                // on the crypto class in order to encrypt / start sessions
-                // @ts-ignore Mock
-                mockCrypto.encryptAndSendToDevices = Crypto.prototype.encryptAndSendToDevices;
-                // @ts-ignore Mock
-                mockCrypto.olmDevice = olmDevice;
-                // @ts-ignore Mock
-                mockCrypto.baseApis = mockBaseApis;
-
-                mockRoom = {
-                    getEncryptionTargetMembers: jest.fn().mockReturnValue(
-                        [{ userId: "@alice:home.server" }],
-                    ),
-                    getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
-                };
-            });
-
-            it("should use larger otkTimeout when preparing to encrypt room", async () => {
-                megolmEncryption.prepareToEncrypt(mockRoom);
-                await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-                expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
-
-                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 10000,
-                );
-            });
-
-            it("should generate a new session if this one needs rotation", async () => {
-                const session = await megolmEncryption.prepareNewSession(false);
-                session.creationTime -= rotationPeriodMs + 10000; // a smidge over the rotation time
-                // Inject expired session which needs rotation
-                megolmEncryption.setupPromise = Promise.resolve(session);
-
-                const prepareNewSessionSpy = jest.spyOn(megolmEncryption, "prepareNewSession");
-                await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-                expect(prepareNewSessionSpy).toHaveBeenCalledTimes(1);
-            });
-
-            it("re-uses sessions for sequential messages", async function() {
-                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-                expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
-
-                // this should have claimed a key for alice as it's starting a new session
-                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-                );
-                expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
-                    ['@alice:home.server'], false,
-                );
-                expect(mockBaseApis.queueToDevice).toHaveBeenCalled();
-                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-                );
-
-                mockBaseApis.claimOneTimeKeys.mockReset();
-
-                const ct2 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some more text",
-                });
-
-                // this should *not* have claimed a key as it should be using the same session
-                expect(mockBaseApis.claimOneTimeKeys).not.toHaveBeenCalled();
-
-                // likewise they should show the same session ID
-                expect(ct2.session_id).toEqual(ct1.session_id);
-            });
-
-            it("re-shares keys to devices it's already sent to", async function() {
-                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-
-                mockBaseApis.sendToDevice.mockClear();
-                await megolmEncryption.reshareKeyWithDevice(
-                    olmDevice.deviceCurve25519Key,
-                    ct1.session_id,
-                    '@alice:home.server',
-                    aliceDeviceInfo,
-                );
-
-                expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
-            });
-
-            it("does not re-share keys to devices whose keys have changed", async function() {
-                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                    body: "Some text",
-                });
-
-                aliceDeviceInfo.getIdentityKey = jest.fn().mockReturnValue(
-                    'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWI',
-                );
-
-                mockBaseApis.queueToDevice.mockClear();
-                await megolmEncryption.reshareKeyWithDevice(
-                    olmDevice.deviceCurve25519Key,
-                    ct1.session_id,
-                    '@alice:home.server',
-                    aliceDeviceInfo,
-                );
-
-                expect(mockBaseApis.queueToDevice).not.toHaveBeenCalled();
-            });
-        });
-    });
-
-    it("notifies devices that have been blocked", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient1 = (new TestClient(
-            "@bob:example.com", "bobdevice1",
-        )).client;
-        const bobClient2 = (new TestClient(
-            "@bob:example.com", "bobdevice2",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient1.initCrypto(),
-            bobClient2.initCrypto(),
-        ]);
-        const aliceDevice = aliceClient.crypto!.olmDevice;
-        const bobDevice1 = bobClient1.crypto!.olmDevice;
-        const bobDevice2 = bobClient2.crypto!.olmDevice;
-
-        const encryptionCfg = {
-            "algorithm": "m.megolm.v1.aes-sha2",
-        };
-        const roomId = "!someroom";
-        const room = new Room(roomId, aliceClient, "@alice:example.com", {});
-
-        const bobMember = new RoomMember(roomId, "@bob:example.com");
-        room.getEncryptionTargetMembers = async function() {
-            return [bobMember];
-        };
-        room.setBlacklistUnverifiedDevices(true);
-        aliceClient.store.storeRoom(room);
-        await aliceClient.setRoomEncryption(roomId, encryptionCfg);
-
-        const BOB_DEVICES: Record<string, IDevice> = {
-            bobdevice1: {
-                algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                keys: {
-                    "ed25519:Dynabook": bobDevice1.deviceEd25519Key!,
-                    "curve25519:Dynabook": bobDevice1.deviceCurve25519Key!,
-                },
-                verified: 0,
-                known: false,
-            },
-            bobdevice2: {
-                algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                keys: {
-                    "ed25519:Dynabook": bobDevice2.deviceEd25519Key!,
-                    "curve25519:Dynabook": bobDevice2.deviceCurve25519Key!,
-                },
-                verified: -1,
-                known: false,
-            },
-        };
-
-        aliceClient.crypto!.deviceList.storeDevicesForUser(
-            "@bob:example.com", BOB_DEVICES,
-        );
-        aliceClient.crypto!.deviceList.downloadKeys = async function(userIds) {
-            // @ts-ignore short-circuiting private method
-            return this.getDevicesFromStore(userIds);
-        };
-
-        aliceClient.sendToDevice = jest.fn().mockResolvedValue({});
-
-        const event = new MatrixEvent({
-            type: "m.room.message",
-            sender: "@alice:example.com",
-            room_id: roomId,
-            event_id: "$event",
-            content: {
-                msgtype: "m.text",
-                body: "secret",
-            },
-        });
-        await aliceClient.crypto!.encryptEvent(event, room);
-
-        expect(aliceClient.sendToDevice).toHaveBeenCalled();
-        const [msgtype, contentMap] = mocked(aliceClient.sendToDevice).mock.calls[0];
-        expect(msgtype).toMatch(/^(org.matrix|m).room_key.withheld$/);
-        delete contentMap["@bob:example.com"].bobdevice1.session_id;
-        delete contentMap["@bob:example.com"].bobdevice2.session_id;
-        expect(contentMap).toStrictEqual({
-            '@bob:example.com': {
-                bobdevice1: {
-                    algorithm: "m.megolm.v1.aes-sha2",
-                    room_id: roomId,
-                    code: 'm.unverified',
-                    reason:
-                    'The sender has disabled encrypting to unverified devices.',
-                    sender_key: aliceDevice.deviceCurve25519Key,
-                },
-                bobdevice2: {
-                    algorithm: "m.megolm.v1.aes-sha2",
-                    room_id: roomId,
-                    code: 'm.blacklisted',
-                    reason: 'The sender has blocked you.',
-                    sender_key: aliceDevice.deviceCurve25519Key,
-                },
-            },
-        });
-
-        aliceClient.stopClient();
-        bobClient1.stopClient();
-        bobClient2.stopClient();
-    });
-
-    it("does not block unverified devices when sending verification events", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
-        const bobDevice = bobClient.crypto!.olmDevice;
-
-        const encryptionCfg = {
-            "algorithm": "m.megolm.v1.aes-sha2",
-        };
-        const roomId = "!someroom";
-        const room = new Room(roomId, aliceClient, "@alice:example.com", {});
-
-        const bobMember = new RoomMember(roomId, "@bob:example.com");
-        room.getEncryptionTargetMembers = async function() {
-            return [bobMember];
-        };
-        room.setBlacklistUnverifiedDevices(true);
-        aliceClient.store.storeRoom(room);
-        await aliceClient.setRoomEncryption(roomId, encryptionCfg);
-
-        const BOB_DEVICES: Record<string, IDevice> = {
-            bobdevice: {
-                algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                keys: {
-                    "ed25519:bobdevice": bobDevice.deviceEd25519Key!,
-                    "curve25519:bobdevice": bobDevice.deviceCurve25519Key!,
-                },
-                verified: 0,
-                known: true,
-            },
-        };
-
-        aliceClient.crypto!.deviceList.storeDevicesForUser(
-            "@bob:example.com", BOB_DEVICES,
-        );
-        aliceClient.crypto!.deviceList.downloadKeys = async function(userIds) {
-            // @ts-ignore private
-            return this.getDevicesFromStore(userIds);
-        };
-
-        await bobDevice.generateOneTimeKeys(1);
-        const oneTimeKeys = await bobDevice.getOneTimeKeys();
-        const signedOneTimeKeys: Record<string, { key: string, signatures: object }> = {};
-        for (const keyId in oneTimeKeys.curve25519) {
-            if (oneTimeKeys.curve25519.hasOwnProperty(keyId)) {
-                const k = {
-                    key: oneTimeKeys.curve25519[keyId],
-                    signatures: {},
-                };
-                signedOneTimeKeys["signed_curve25519:" + keyId] = k;
-                await bobClient.crypto!.signObject(k);
-                break;
-            }
-        }
-
-        aliceClient.claimOneTimeKeys = jest.fn().mockResolvedValue({
-            one_time_keys: {
-                '@bob:example.com': {
-                    bobdevice: signedOneTimeKeys,
-                },
-            },
-            failures: {},
-        });
-
-        aliceClient.sendToDevice = jest.fn().mockResolvedValue({});
-
-        const event = new MatrixEvent({
-            type: "m.key.verification.start",
-            sender: "@alice:example.com",
-            room_id: roomId,
-            event_id: "$event",
-            content: {
-                from_device: "alicedevice",
-                method: "m.sas.v1",
-                transaction_id: "transactionid",
-            },
-        });
-        await aliceClient.crypto!.encryptEvent(event, room);
-
-        expect(aliceClient.sendToDevice).toHaveBeenCalled();
-        const [msgtype] = mocked(aliceClient.sendToDevice).mock.calls[0];
-        expect(msgtype).toEqual("m.room.encrypted");
-
-        aliceClient.stopClient();
-        bobClient.stopClient();
-    });
-
-    it("notifies devices when unable to create olm session", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
-        const aliceDevice = aliceClient.crypto!.olmDevice;
-        const bobDevice = bobClient.crypto!.olmDevice;
-
-        const encryptionCfg = {
-            "algorithm": "m.megolm.v1.aes-sha2",
-        };
-        const roomId = "!someroom";
-        const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
-        const bobRoom = new Room(roomId, bobClient, "@bob:example.com", {});
-        aliceClient.store.storeRoom(aliceRoom);
-        bobClient.store.storeRoom(bobRoom);
-        await aliceClient.setRoomEncryption(roomId, encryptionCfg);
-        await bobClient.setRoomEncryption(roomId, encryptionCfg);
-
-        aliceRoom.getEncryptionTargetMembers = jest.fn().mockResolvedValue([
-            {
-                userId: "@alice:example.com",
-                membership: "join",
-            },
-            {
-                userId: "@bob:example.com",
-                membership: "join",
-            },
-        ]);
-        const BOB_DEVICES = {
-            bobdevice: {
-                user_id: "@bob:example.com",
-                device_id: "bobdevice",
-                algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
-                keys: {
-                    "ed25519:bobdevice": bobDevice.deviceEd25519Key!,
-                    "curve25519:bobdevice": bobDevice.deviceCurve25519Key!,
-                },
-                known: true,
-                verified: 1,
-            },
-        };
-
-        aliceClient.crypto!.deviceList.storeDevicesForUser(
-            "@bob:example.com", BOB_DEVICES,
-        );
-        aliceClient.crypto!.deviceList.downloadKeys = async function(userIds) {
-            // @ts-ignore private
-            return this.getDevicesFromStore(userIds);
-        };
-
-        aliceClient.claimOneTimeKeys = jest.fn().mockResolvedValue({
-            // Bob has no one-time keys
-            one_time_keys: {},
-            failures: {},
-        });
-
-        aliceClient.sendToDevice = jest.fn().mockResolvedValue({});
-
-        const event = new MatrixEvent({
-            type: "m.room.message",
-            sender: "@alice:example.com",
-            room_id: roomId,
-            event_id: "$event",
-            content: {},
-        });
-        await aliceClient.crypto!.encryptEvent(event, aliceRoom);
-
-        expect(aliceClient.sendToDevice).toHaveBeenCalled();
-        const [msgtype, contentMap] = mocked(aliceClient.sendToDevice).mock.calls[0];
-        expect(msgtype).toMatch(/^(org.matrix|m).room_key.withheld$/);
-        expect(contentMap).toStrictEqual({
-            '@bob:example.com': {
-                bobdevice: {
-                    algorithm: "m.megolm.v1.aes-sha2",
-                    code: 'm.no_olm',
-                    reason: 'Unable to establish a secure channel.',
-                    sender_key: aliceDevice.deviceCurve25519Key,
-                },
-            },
-        });
-
-        aliceClient.stopClient();
-        bobClient.stopClient();
-    });
-
-    it("throws an error describing why it doesn't have a key", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
-        const bobDevice = bobClient.crypto!.olmDevice;
-
-        const aliceEventEmitter = new TypedEventEmitter<ClientEvent.ToDeviceEvent, any>();
-        aliceClient.crypto!.registerEventHandlers(aliceEventEmitter);
-
-        const roomId = "!someroom";
-
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id1",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.blacklisted",
-                reason: "You have been blocked",
-            },
-        }));
-
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id1",
-            },
-        }))).rejects.toThrow("The sender has blocked you.");
-
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id2",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.blacklisted",
-                reason: "You have been blocked",
-            },
-        }));
-
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id2",
-            },
-        }))).rejects.toThrow("The sender has blocked you.");
-        aliceClient.stopClient();
-        bobClient.stopClient();
-    });
-
-    it("throws an error describing the lack of an olm session", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
-
-        const aliceEventEmitter = new TypedEventEmitter<ClientEvent.ToDeviceEvent, any>();
-        aliceClient.crypto!.registerEventHandlers(aliceEventEmitter);
-
-        aliceClient.crypto!.downloadKeys = jest.fn();
-        const bobDevice = bobClient.crypto!.olmDevice;
-
-        const roomId = "!someroom";
-
-        const now = Date.now();
-
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id1",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.no_olm",
-                reason: "Unable to establish a secure channel.",
-            },
-        }));
-
-        await new Promise((resolve) => {
-            setTimeout(resolve, 100);
-        });
-
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id1",
-            },
-            origin_server_ts: now,
-        }))).rejects.toThrow("The sender was unable to establish a secure channel.");
-
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id2",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.no_olm",
-                reason: "Unable to establish a secure channel.",
-            },
-        }));
-
-        await new Promise((resolve) => {
-            setTimeout(resolve, 100);
-        });
-
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id2",
-            },
-            origin_server_ts: now,
-        }))).rejects.toThrow("The sender was unable to establish a secure channel.");
-        aliceClient.stopClient();
-        bobClient.stopClient();
-    });
-
-    it("throws an error to indicate a wedged olm session", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
-        const aliceEventEmitter = new TypedEventEmitter<ClientEvent.ToDeviceEvent, any>();
-        aliceClient.crypto!.registerEventHandlers(aliceEventEmitter);
-
-        const bobDevice = bobClient.crypto!.olmDevice;
-        aliceClient.crypto!.downloadKeys = jest.fn();
-
-        const roomId = "!someroom";
-
-        const now = Date.now();
-
-        // pretend we got an event that we can't decrypt
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            content: {
-                msgtype: "m.bad.encrypted",
-                algorithm: "m.megolm.v1.aes-sha2",
-                session_id: "session_id",
-                sender_key: bobDevice.deviceCurve25519Key,
-            },
-        }));
-
-        await new Promise((resolve) => {
-            setTimeout(resolve, 100);
-        });
-
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id",
-            },
-            origin_server_ts: now,
-        }))).rejects.toThrow("The secure channel with the sender was corrupted.");
-        aliceClient.stopClient();
-        bobClient.stopClient();
-    });
-});
@@ -0,0 +1,86 @@
+/*
+Copyright 2018 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.
+*/
+
+import '../../../olm-loader';
+
+import expect from 'expect';
+import WebStorageSessionStore from '../../../../lib/store/session/webstorage';
+import MemoryCryptoStore from '../../../../lib/crypto/store/memory-crypto-store.js';
+import MockStorageApi from '../../../MockStorageApi';
+import testUtils from '../../../test-utils';
+
+import OlmDevice from '../../../../lib/crypto/OlmDevice';
+
+function makeOlmDevice() {
+    const mockStorage = new MockStorageApi();
+    const sessionStore = new WebStorageSessionStore(mockStorage);
+    const cryptoStore = new MemoryCryptoStore(mockStorage);
+    const olmDevice = new OlmDevice(sessionStore, cryptoStore);
+    return olmDevice;
+}
+
+async function setupSession(initiator, opponent) {
+    await opponent.generateOneTimeKeys(1);
+    const keys = await opponent.getOneTimeKeys();
+    const firstKey = Object.values(keys['curve25519'])[0];
+
+    const sid = await initiator.createOutboundSession(
+        opponent.deviceCurve25519Key, firstKey,
+    );
+    return sid;
+}
+
+describe("OlmDecryption", function() {
+    if (!global.Olm) {
+        console.warn('Not running megolm unit tests: libolm not present');
+        return;
+    }
+
+    let aliceOlmDevice;
+    let bobOlmDevice;
+
+    beforeEach(async function() {
+        testUtils.beforeEach(this); // eslint-disable-line no-invalid-this
+
+        await global.Olm.init();
+
+        aliceOlmDevice = makeOlmDevice();
+        bobOlmDevice = makeOlmDevice();
+        await aliceOlmDevice.init();
+        await bobOlmDevice.init();
+    });
+
+    describe('olm', function() {
+        it("can decrypt messages", async function() {
+            const sid = await setupSession(aliceOlmDevice, bobOlmDevice);
+
+            const ciphertext = await aliceOlmDevice.encryptMessage(
+                bobOlmDevice.deviceCurve25519Key,
+                sid,
+                "The olm or proteus is an aquatic salamander in the family Proteidae",
+            );
+
+            const result = await bobOlmDevice.createInboundSession(
+                aliceOlmDevice.deviceCurve25519Key,
+                ciphertext.type,
+                ciphertext.body,
+            );
+            expect(result.payload).toEqual(
+                "The olm or proteus is an aquatic salamander in the family Proteidae",
+            );
+        });
+    });
+});
@@ -1,281 +0,0 @@
-/*
-Copyright 2018,2019 New Vector Ltd
-Copyright 2019, 2022 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import { MockedObject } from 'jest-mock';
-
-import '../../../olm-loader';
-import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
-import { logger } from "../../../../src/logger";
-import { OlmDevice } from "../../../../src/crypto/OlmDevice";
-import * as olmlib from "../../../../src/crypto/olmlib";
-import { DeviceInfo } from "../../../../src/crypto/deviceinfo";
-import { MatrixClient } from '../../../../src';
-
-function makeOlmDevice() {
-    const cryptoStore = new MemoryCryptoStore();
-    const olmDevice = new OlmDevice(cryptoStore);
-    return olmDevice;
-}
-
-async function setupSession(initiator, opponent) {
-    await opponent.generateOneTimeKeys(1);
-    const keys = await opponent.getOneTimeKeys();
-    const firstKey = Object.values(keys['curve25519'])[0];
-
-    const sid = await initiator.createOutboundSession(
-        opponent.deviceCurve25519Key, firstKey,
-    );
-    return sid;
-}
-
-describe("OlmDevice", function() {
-    if (!global.Olm) {
-        logger.warn('Not running megolm unit tests: libolm not present');
-        return;
-    }
-
-    beforeAll(function() {
-        return global.Olm.init();
-    });
-
-    let aliceOlmDevice: OlmDevice;
-    let bobOlmDevice: OlmDevice;
-
-    beforeEach(async function() {
-        aliceOlmDevice = makeOlmDevice();
-        bobOlmDevice = makeOlmDevice();
-        await aliceOlmDevice.init();
-        await bobOlmDevice.init();
-    });
-
-    describe('olm', function() {
-        it("can decrypt messages", async function() {
-            const sid = await setupSession(aliceOlmDevice, bobOlmDevice);
-
-            const ciphertext = await aliceOlmDevice.encryptMessage(
-                bobOlmDevice.deviceCurve25519Key!,
-                sid,
-                "The olm or proteus is an aquatic salamander in the family Proteidae",
-            ) as any; // OlmDevice.encryptMessage has incorrect return type
-
-            const result = await bobOlmDevice.createInboundSession(
-                aliceOlmDevice.deviceCurve25519Key!,
-                ciphertext.type,
-                ciphertext.body,
-            );
-            expect(result.payload).toEqual(
-                "The olm or proteus is an aquatic salamander in the family Proteidae",
-            );
-        });
-
-        it('exports picked account and olm sessions', async function() {
-            const sessionId = await setupSession(aliceOlmDevice, bobOlmDevice);
-
-            const exported = await bobOlmDevice.export();
-            // At this moment only Alice (the “initiator” in setupSession) has a session
-            expect(exported.sessions).toEqual([]);
-
-            const MESSAGE = (
-                "The olm or proteus is an aquatic salamander"
-                + " in the family Proteidae"
-            );
-            const ciphertext = await aliceOlmDevice.encryptMessage(
-                bobOlmDevice.deviceCurve25519Key!,
-                sessionId,
-                MESSAGE,
-            ) as any; // OlmDevice.encryptMessage has incorrect return type
-
-            const bobRecreatedOlmDevice = makeOlmDevice();
-            bobRecreatedOlmDevice.init({ fromExportedDevice: exported });
-
-            const decrypted = await bobRecreatedOlmDevice.createInboundSession(
-                aliceOlmDevice.deviceCurve25519Key!,
-                ciphertext.type,
-                ciphertext.body,
-            );
-            expect(decrypted.payload).toEqual(MESSAGE);
-
-            const exportedAgain = await bobRecreatedOlmDevice.export();
-            // this time we expect Bob to have a session to export
-            expect(exportedAgain.sessions).toHaveLength(1);
-
-            const MESSAGE_2 = (
-                "In contrast to most amphibians,"
-                + " the olm is entirely aquatic"
-            );
-            const ciphertext2 = await aliceOlmDevice.encryptMessage(
-                bobOlmDevice.deviceCurve25519Key!,
-                sessionId,
-                MESSAGE_2,
-            ) as any; // OlmDevice.encryptMessage has incorrect return type
-
-            const bobRecreatedAgainOlmDevice = makeOlmDevice();
-            bobRecreatedAgainOlmDevice.init({ fromExportedDevice: exportedAgain });
-
-            // Note: "decrypted_2" does not have the same structure as "decrypted"
-            const decrypted2 = await bobRecreatedAgainOlmDevice.decryptMessage(
-                aliceOlmDevice.deviceCurve25519Key!,
-                decrypted.session_id,
-                ciphertext2.type,
-                ciphertext2.body,
-            );
-            expect(decrypted2).toEqual(MESSAGE_2);
-        });
-
-        it("creates only one session at a time", async function() {
-            // if we call ensureOlmSessionsForDevices multiple times, it should
-            // only try to create one session at a time, even if the server is
-            // slow
-            let count = 0;
-            const baseApis = {
-                claimOneTimeKeys: () => {
-                    // simulate a very slow server (.5 seconds to respond)
-                    count++;
-                    return new Promise((resolve, reject) => {
-                        setTimeout(reject, 500);
-                    });
-                },
-            } as unknown as MockedObject<MatrixClient>;
-            const devicesByUser = {
-                "@bob:example.com": [
-                    DeviceInfo.fromStorage({
-                        keys: {
-                            "curve25519:ABCDEFG": "akey",
-                        },
-                    }, "ABCDEFG"),
-                ],
-            };
-            function alwaysSucceed(promise) {
-                // swallow any exception thrown by a promise, so that
-                // Promise.all doesn't abort
-                return promise.catch(() => {});
-            }
-
-            // start two tasks that try to ensure that there's an olm session
-            const promises = Promise.all([
-                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                    aliceOlmDevice, baseApis, devicesByUser,
-                )),
-                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                    aliceOlmDevice, baseApis, devicesByUser,
-                )),
-            ]);
-
-            await new Promise((resolve) => {
-                setTimeout(resolve, 200);
-            });
-
-            // after .2s, both tasks should have started, but one should be
-            // waiting on the other before trying to create a session, so
-            // claimOneTimeKeys should have only been called once
-            expect(count).toBe(1);
-
-            await promises;
-
-            // after waiting for both tasks to complete, the first task should
-            // have failed, so the second task should have tried to create a
-            // new session and will have called claimOneTimeKeys
-            expect(count).toBe(2);
-        });
-
-        it("avoids deadlocks when two tasks are ensuring the same devices", async function() {
-            // This test checks whether `ensureOlmSessionsForDevices` properly
-            // handles multiple tasks in flight ensuring some set of devices in
-            // common without deadlocks.
-
-            let claimRequestCount = 0;
-            const baseApis = {
-                claimOneTimeKeys: () => {
-                    // simulate a very slow server (.5 seconds to respond)
-                    claimRequestCount++;
-                    return new Promise((resolve, reject) => {
-                        setTimeout(reject, 500);
-                    });
-                },
-            } as unknown as MockedObject<MatrixClient>;
-
-            const deviceBobA = DeviceInfo.fromStorage({
-                keys: {
-                    "curve25519:BOB-A": "akey",
-                },
-            }, "BOB-A");
-            const deviceBobB = DeviceInfo.fromStorage({
-                keys: {
-                    "curve25519:BOB-B": "bkey",
-                },
-            }, "BOB-B");
-
-            // There's no required ordering of devices per user, so here we
-            // create two different orderings so that each task reserves a
-            // device the other task needs before continuing.
-            const devicesByUserAB = {
-                "@bob:example.com": [
-                    deviceBobA,
-                    deviceBobB,
-                ],
-            };
-            const devicesByUserBA = {
-                "@bob:example.com": [
-                    deviceBobB,
-                    deviceBobA,
-                ],
-            };
-
-            function alwaysSucceed(promise) {
-                // swallow any exception thrown by a promise, so that
-                // Promise.all doesn't abort
-                return promise.catch(() => {});
-            }
-
-            const task1 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                aliceOlmDevice, baseApis, devicesByUserAB,
-            ));
-
-            // After a single tick through the first task, it should have
-            // claimed ownership of all devices to avoid deadlocking others.
-            expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);
-
-            const task2 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                aliceOlmDevice, baseApis, devicesByUserBA,
-            ));
-
-            // The second task should not have changed the ownership count, as
-            // it's waiting on the first task.
-            expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);
-
-            // Track the tasks, but don't await them yet.
-            const promises = Promise.all([
-                task1,
-                task2,
-            ]);
-
-            await new Promise((resolve) => {
-                setTimeout(resolve, 200);
-            });
-
-            // After .2s, the first task should have made an initial claim request.
-            expect(claimRequestCount).toBe(1);
-
-            await promises;
-
-            // After waiting for both tasks to complete, the first task should
-            // have failed, so the second task should have tried to create a
-            // new session and will have called claimOneTimeKeys
-            expect(claimRequestCount).toBe(2);
-        });
-    });
-});
@@ -0,0 +1,467 @@
+/*
+Copyright 2018 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.
+*/
+
+import '../../olm-loader';
+
+import expect from 'expect';
+import Promise from 'bluebird';
+
+import sdk from '../../..';
+import algorithms from '../../../lib/crypto/algorithms';
+import WebStorageSessionStore from '../../../lib/store/session/webstorage';
+import MemoryCryptoStore from '../../../lib/crypto/store/memory-crypto-store.js';
+import MockStorageApi from '../../MockStorageApi';
+import testUtils from '../../test-utils';
+
+import OlmDevice from '../../../lib/crypto/OlmDevice';
+import Crypto from '../../../lib/crypto';
+
+const Olm = global.Olm;
+
+const MatrixClient = sdk.MatrixClient;
+const MatrixEvent = sdk.MatrixEvent;
+const MegolmDecryption = algorithms.DECRYPTION_CLASSES['m.megolm.v1.aes-sha2'];
+
+const ROOM_ID = '!ROOM:ID';
+
+const SESSION_ID = 'o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc';
+const ENCRYPTED_EVENT = new MatrixEvent({
+    type: 'm.room.encrypted',
+    room_id: '!ROOM:ID',
+    content: {
+        algorithm: 'm.megolm.v1.aes-sha2',
+        sender_key: 'SENDER_CURVE25519',
+        session_id: SESSION_ID,
+        ciphertext: 'AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N'
+            + 'CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl'
+            + 'mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs',
+    },
+    event_id: '$event1',
+    origin_server_ts: 1507753886000,
+});
+
+const KEY_BACKUP_DATA = {
+    first_message_index: 0,
+    forwarded_count: 0,
+    is_verified: false,
+    session_data: {
+        ciphertext: '2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw'
+            + '6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ'
+            + 'Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9'
+            + 'SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy'
+            + 'Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF'
+            + 'ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV'
+            + '4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv'
+            + 'C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe'
+            + 'Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf'
+            + 'QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy'
+            + 'iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg',
+        mac: '5lxYBHQU80M',
+        ephemeral: '/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14',
+    },
+};
+
+function makeTestClient(sessionStore, cryptoStore) {
+    const scheduler = [
+        "getQueueForEvent", "queueEvent", "removeEventFromQueue",
+        "setProcessFunction",
+    ].reduce((r, k) => {r[k] = expect.createSpy(); return r;}, {});
+    const store = [
+        "getRoom", "getRooms", "getUser", "getSyncToken", "scrollback",
+        "save", "wantsSave", "setSyncToken", "storeEvents", "storeRoom",
+        "storeUser", "getFilterIdByName", "setFilterIdByName", "getFilter",
+        "storeFilter", "getSyncAccumulator", "startup", "deleteAllData",
+    ].reduce((r, k) => {r[k] = expect.createSpy(); return r;}, {});
+    store.getSavedSync = expect.createSpy().andReturn(Promise.resolve(null));
+    store.getSavedSyncToken = expect.createSpy().andReturn(Promise.resolve(null));
+    store.setSyncData = expect.createSpy().andReturn(Promise.resolve(null));
+    return new MatrixClient({
+        baseUrl: "https://my.home.server",
+        idBaseUrl: "https://identity.server",
+        accessToken: "my.access.token",
+        request: function() {}, // NOP
+        store: store,
+        scheduler: scheduler,
+        userId: "@alice:bar",
+        deviceId: "device",
+        sessionStore: sessionStore,
+        cryptoStore: cryptoStore,
+    });
+}
+
+describe("MegolmBackup", function() {
+    if (!global.Olm) {
+        console.warn('Not running megolm backup unit tests: libolm not present');
+        return;
+    }
+
+    let olmDevice;
+    let mockOlmLib;
+    let mockCrypto;
+    let mockStorage;
+    let sessionStore;
+    let cryptoStore;
+    let megolmDecryption;
+    beforeEach(async function() {
+        await Olm.init();
+        testUtils.beforeEach(this); // eslint-disable-line no-invalid-this
+
+        mockCrypto = testUtils.mock(Crypto, 'Crypto');
+        mockCrypto.backupKey = new Olm.PkEncryption();
+        mockCrypto.backupKey.set_recipient_key(
+            "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
+        );
+        mockCrypto.backupInfo = {
+            algorithm: "m.megolm_backup.v1",
+            version: 1,
+            auth_data: {
+                public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
+            },
+        };
+
+        mockStorage = new MockStorageApi();
+        sessionStore = new WebStorageSessionStore(mockStorage);
+        cryptoStore = new MemoryCryptoStore(mockStorage);
+
+        olmDevice = new OlmDevice(sessionStore, cryptoStore);
+
+        // we stub out the olm encryption bits
+        mockOlmLib = {};
+        mockOlmLib.ensureOlmSessionsForDevices = expect.createSpy();
+        mockOlmLib.encryptMessageForDevice =
+            expect.createSpy().andReturn(Promise.resolve());
+    });
+
+    describe("backup", function() {
+        let mockBaseApis;
+        let realSetTimeout;
+
+        beforeEach(function() {
+            mockBaseApis = {};
+
+            megolmDecryption = new MegolmDecryption({
+                userId: '@user:id',
+                crypto: mockCrypto,
+                olmDevice: olmDevice,
+                baseApis: mockBaseApis,
+                roomId: ROOM_ID,
+            });
+
+            megolmDecryption.olmlib = mockOlmLib;
+
+            // clobber the setTimeout function to run 100x faster.
+            // ideally we would use lolex, but we have no oportunity
+            // to tick the clock between the first try and the retry.
+            realSetTimeout = global.setTimeout;
+            global.setTimeout = function(f, n) {
+                return realSetTimeout(f, n/100);
+            };
+        });
+
+        afterEach(function() {
+            global.setTimeout = realSetTimeout;
+        });
+
+        it('automatically calls the key back up', function() {
+            const groupSession = new Olm.OutboundGroupSession();
+            groupSession.create();
+
+            // construct a fake decrypted key event via the use of a mocked
+            // 'crypto' implementation.
+            const event = new MatrixEvent({
+                type: 'm.room.encrypted',
+            });
+            const decryptedData = {
+                clearEvent: {
+                    type: 'm.room_key',
+                    content: {
+                        algorithm: 'm.megolm.v1.aes-sha2',
+                        room_id: ROOM_ID,
+                        session_id: groupSession.session_id(),
+                        session_key: groupSession.session_key(),
+                    },
+                },
+                senderCurve25519Key: "SENDER_CURVE25519",
+                claimedEd25519Key: "SENDER_ED25519",
+            };
+
+            mockCrypto.decryptEvent = function() {
+                return Promise.resolve(decryptedData);
+            };
+            mockCrypto.cancelRoomKeyRequest = function() {};
+
+            mockCrypto.backupGroupSession = expect.createSpy();
+
+            return event.attemptDecryption(mockCrypto).then(() => {
+                return megolmDecryption.onRoomKeyEvent(event);
+            }).then(() => {
+                expect(mockCrypto.backupGroupSession).toHaveBeenCalled();
+            });
+        });
+
+        it('sends backups to the server', function() {
+            const groupSession = new Olm.OutboundGroupSession();
+            groupSession.create();
+            const ibGroupSession = new Olm.InboundGroupSession();
+            ibGroupSession.create(groupSession.session_key());
+
+            const client = makeTestClient(sessionStore, cryptoStore);
+
+            megolmDecryption = new MegolmDecryption({
+                userId: '@user:id',
+                crypto: mockCrypto,
+                olmDevice: olmDevice,
+                baseApis: client,
+                roomId: ROOM_ID,
+            });
+
+            megolmDecryption.olmlib = mockOlmLib;
+
+            return client.initCrypto()
+                .then(() => {
+                    return cryptoStore.doTxn(
+                        "readwrite",
+                        [cryptoStore.STORE_SESSION],
+                        (txn) => {
+                            cryptoStore.addEndToEndInboundGroupSession(
+                                "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                                groupSession.session_id(),
+                                {
+                                    forwardingCurve25519KeyChain: undefined,
+                                    keysClaimed: {
+                                        ed25519: "SENDER_ED25519",
+                                    },
+                                    room_id: ROOM_ID,
+                                    session: ibGroupSession.pickle(olmDevice._pickleKey),
+                                },
+                                txn);
+                        });
+                })
+                .then(() => {
+                    client.enableKeyBackup({
+                        algorithm: "m.megolm_backup.v1",
+                        version: 1,
+                        auth_data: {
+                            public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
+                        },
+                    });
+                    let numCalls = 0;
+                    return new Promise((resolve, reject) => {
+                        client._http.authedRequest = function(
+                            callback, method, path, queryParams, data, opts,
+                        ) {
+                            ++numCalls;
+                            expect(numCalls).toBeLessThanOrEqualTo(1);
+                            if (numCalls >= 2) {
+                                // exit out of retry loop if there's something wrong
+                                reject(new Error("authedRequest called too many timmes"));
+                                return Promise.resolve({});
+                            }
+                            expect(method).toBe("PUT");
+                            expect(path).toBe("/room_keys/keys");
+                            expect(queryParams.version).toBe(1);
+                            expect(data.rooms[ROOM_ID].sessions).toExist();
+                            expect(data.rooms[ROOM_ID].sessions).toIncludeKey(
+                                groupSession.session_id(),
+                            );
+                            resolve();
+                            return Promise.resolve({});
+                        };
+                        client._crypto.backupGroupSession(
+                            "roomId",
+                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                            [],
+                            groupSession.session_id(),
+                            groupSession.session_key(),
+                        );
+                    }).then(() => {
+                        expect(numCalls).toBe(1);
+                    });
+                });
+        });
+
+        it('retries when a backup fails', function() {
+            const groupSession = new Olm.OutboundGroupSession();
+            groupSession.create();
+            const ibGroupSession = new Olm.InboundGroupSession();
+            ibGroupSession.create(groupSession.session_key());
+
+            const scheduler = [
+                "getQueueForEvent", "queueEvent", "removeEventFromQueue",
+                "setProcessFunction",
+            ].reduce((r, k) => {r[k] = expect.createSpy(); return r;}, {});
+            const store = [
+                "getRoom", "getRooms", "getUser", "getSyncToken", "scrollback",
+                "save", "wantsSave", "setSyncToken", "storeEvents", "storeRoom",
+                "storeUser", "getFilterIdByName", "setFilterIdByName", "getFilter",
+                "storeFilter", "getSyncAccumulator", "startup", "deleteAllData",
+            ].reduce((r, k) => {r[k] = expect.createSpy(); return r;}, {});
+            store.getSavedSync = expect.createSpy().andReturn(Promise.resolve(null));
+            store.getSavedSyncToken = expect.createSpy().andReturn(Promise.resolve(null));
+            store.setSyncData = expect.createSpy().andReturn(Promise.resolve(null));
+            const client = new MatrixClient({
+                baseUrl: "https://my.home.server",
+                idBaseUrl: "https://identity.server",
+                accessToken: "my.access.token",
+                request: function() {}, // NOP
+                store: store,
+                scheduler: scheduler,
+                userId: "@alice:bar",
+                deviceId: "device",
+                sessionStore: sessionStore,
+                cryptoStore: cryptoStore,
+            });
+
+            megolmDecryption = new MegolmDecryption({
+                userId: '@user:id',
+                crypto: mockCrypto,
+                olmDevice: olmDevice,
+                baseApis: client,
+                roomId: ROOM_ID,
+            });
+
+            megolmDecryption.olmlib = mockOlmLib;
+
+            return client.initCrypto()
+                .then(() => {
+                    return cryptoStore.doTxn(
+                        "readwrite",
+                        [cryptoStore.STORE_SESSION],
+                        (txn) => {
+                            cryptoStore.addEndToEndInboundGroupSession(
+                                "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                                groupSession.session_id(),
+                                {
+                                    forwardingCurve25519KeyChain: undefined,
+                                    keysClaimed: {
+                                        ed25519: "SENDER_ED25519",
+                                    },
+                                    room_id: ROOM_ID,
+                                    session: ibGroupSession.pickle(olmDevice._pickleKey),
+                                },
+                                txn);
+                        });
+                })
+                .then(() => {
+                    client.enableKeyBackup({
+                        algorithm: "foobar",
+                        version: 1,
+                        auth_data: {
+                            public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
+                        },
+                    });
+                    let numCalls = 0;
+                    return new Promise((resolve, reject) => {
+                        client._http.authedRequest = function(
+                            callback, method, path, queryParams, data, opts,
+                        ) {
+                            ++numCalls;
+                            expect(numCalls).toBeLessThanOrEqualTo(2);
+                            if (numCalls >= 3) {
+                                // exit out of retry loop if there's something wrong
+                                reject(new Error("authedRequest called too many timmes"));
+                                return Promise.resolve({});
+                            }
+                            expect(method).toBe("PUT");
+                            expect(path).toBe("/room_keys/keys");
+                            expect(queryParams.version).toBe(1);
+                            expect(data.rooms[ROOM_ID].sessions).toExist();
+                            expect(data.rooms[ROOM_ID].sessions).toIncludeKey(
+                                groupSession.session_id(),
+                            );
+                            if (numCalls > 1) {
+                                resolve();
+                                return Promise.resolve({});
+                            } else {
+                                return Promise.reject(
+                                    new Error("this is an expected failure"),
+                                );
+                            }
+                        };
+                        client._crypto.backupGroupSession(
+                            "roomId",
+                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                            [],
+                            groupSession.session_id(),
+                            groupSession.session_key(),
+                        );
+                    }).then(() => {
+                        expect(numCalls).toBe(2);
+                    });
+                });
+        });
+    });
+
+    describe("restore", function() {
+        let client;
+
+        beforeEach(function() {
+            client = makeTestClient(sessionStore, cryptoStore);
+
+            megolmDecryption = new MegolmDecryption({
+                userId: '@user:id',
+                crypto: mockCrypto,
+                olmDevice: olmDevice,
+                baseApis: client,
+                roomId: ROOM_ID,
+            });
+
+            megolmDecryption.olmlib = mockOlmLib;
+
+            return client.initCrypto();
+        });
+
+        afterEach(function() {
+            client.stopClient();
+        });
+
+        it('can restore from backup', function() {
+            client._http.authedRequest = function() {
+                return Promise.resolve(KEY_BACKUP_DATA);
+            };
+            return client.restoreKeyBackupWithRecoveryKey(
+                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+                ROOM_ID,
+                SESSION_ID,
+            ).then(() => {
+                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
+            }).then((res) => {
+                expect(res.clearEvent.content).toEqual('testytest');
+            });
+        });
+
+        it('can restore backup by room', function() {
+            client._http.authedRequest = function() {
+                return Promise.resolve({
+                    rooms: {
+                        [ROOM_ID]: {
+                            sessions: {
+                                [SESSION_ID]: KEY_BACKUP_DATA,
+                            },
+                        },
+                    },
+                });
+            };
+            return client.restoreKeyBackupWithRecoveryKey(
+                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+            ).then(() => {
+                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
+            }).then((res) => {
+                expect(res.clearEvent.content).toEqual('testytest');
+            });
+        });
+    });
+});
@@ -1,728 +0,0 @@
-/*
-Copyright 2018 New Vector Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import { MockedObject } from "jest-mock";
-
-import '../../olm-loader';
-import { logger } from "../../../src/logger";
-import * as olmlib from "../../../src/crypto/olmlib";
-import { MatrixClient } from "../../../src/client";
-import { MatrixEvent } from "../../../src/models/event";
-import * as algorithms from "../../../src/crypto/algorithms";
-import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
-import * as testUtils from "../../test-utils/test-utils";
-import { OlmDevice } from "../../../src/crypto/OlmDevice";
-import { Crypto } from "../../../src/crypto";
-import { resetCrossSigningKeys } from "./crypto-utils";
-import { BackupManager } from "../../../src/crypto/backup";
-import { StubStore } from "../../../src/store/stub";
-import { MatrixScheduler } from '../../../src';
-
-const Olm = global.Olm;
-
-const MegolmDecryption = algorithms.DECRYPTION_CLASSES.get('m.megolm.v1.aes-sha2')!;
-
-const ROOM_ID = '!ROOM:ID';
-
-const SESSION_ID = 'o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc';
-const ENCRYPTED_EVENT = new MatrixEvent({
-    type: 'm.room.encrypted',
-    room_id: '!ROOM:ID',
-    content: {
-        algorithm: 'm.megolm.v1.aes-sha2',
-        sender_key: 'SENDER_CURVE25519',
-        session_id: SESSION_ID,
-        ciphertext: 'AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N'
-            + 'CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl'
-            + 'mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs',
-    },
-    event_id: '$event1',
-    origin_server_ts: 1507753886000,
-});
-
-const CURVE25519_KEY_BACKUP_DATA = {
-    first_message_index: 0,
-    forwarded_count: 0,
-    is_verified: false,
-    session_data: {
-        ciphertext: '2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw'
-            + '6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ'
-            + 'Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9'
-            + 'SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy'
-            + 'Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF'
-            + 'ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV'
-            + '4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv'
-            + 'C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe'
-            + 'Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf'
-            + 'QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy'
-            + 'iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg',
-        mac: '5lxYBHQU80M',
-        ephemeral: '/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14',
-    },
-};
-
-const AES256_KEY_BACKUP_DATA = {
-    first_message_index: 0,
-    forwarded_count: 0,
-    is_verified: false,
-    session_data: {
-        iv: 'b3Jqqvm5S9QdmXrzssspLQ',
-        ciphertext: 'GOOASO3E9ThogkG0zMjEduGLM3u9jHZTkS7AvNNbNj3q1znwk4OlaVKXce'
-            + '7ynofiiYIiS865VlOqrKEEXv96XzRyUpgn68e3WsicwYl96EtjIEh/iY003PG2Qd'
-            + 'EluT899Ax7PydpUHxEktbWckMppYomUR5q8x1KI1SsOQIiJaIGThmIMPANRCFiK0'
-            + 'WQj+q+dnhzx4lt9AFqU5bKov8qKnw2qGYP7/+6RmJ0Kpvs8tG6lrcNDEHtFc2r0r'
-            + 'KKubDypo0Vc8EWSwsAHdKa36ewRavpreOuE8Z9RLfY0QIR1ecXrMqW0CdGFr7H3P'
-            + 'vcjF8sjwvQAavzxEKT1WMGizSMLeKWo2mgZ5cKnwV5HGUAw596JQvKs9laG2U89K'
-            + 'YrT0sH30vi62HKzcBLcDkWkUSNYPz7UiZ1MM0L380UA+1ZOXSOmtBA9xxzzbc8Xd'
-            + 'fRimVgklGdxrxjzuNLYhL2BvVH4oPWonD9j0bvRwE6XkimdbGQA8HB7UmXXjE8WA'
-            + 'RgaDHkfzoA3g3aeQ',
-        mac: 'uR988UYgGL99jrvLLPX3V1ows+UYbktTmMxPAo2kxnU',
-    },
-};
-
-const CURVE25519_BACKUP_INFO = {
-    algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-    version: '1',
-    auth_data: {
-        public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-    },
-};
-
-const AES256_BACKUP_INFO = {
-    algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
-    version: '1',
-    auth_data: {
-        // FIXME: add iv and mac
-    },
-};
-
-const keys = {};
-
-function getCrossSigningKey(type) {
-    return keys[type];
-}
-
-function saveCrossSigningKeys(k) {
-    Object.assign(keys, k);
-}
-
-function makeTestClient(cryptoStore) {
-    const scheduler = [
-        "getQueueForEvent", "queueEvent", "removeEventFromQueue",
-        "setProcessFunction",
-    ].reduce((r, k) => {r[k] = jest.fn(); return r;}, {}) as MockedObject<MatrixScheduler>;
-    const store = new StubStore();
-
-    return new MatrixClient({
-        baseUrl: "https://my.home.server",
-        idBaseUrl: "https://identity.server",
-        accessToken: "my.access.token",
-        fetchFn: jest.fn(), // NOP
-        store: store,
-        scheduler: scheduler,
-        userId: "@alice:bar",
-        deviceId: "device",
-        cryptoStore: cryptoStore,
-        cryptoCallbacks: { getCrossSigningKey, saveCrossSigningKeys },
-    });
-}
-
-describe("MegolmBackup", function() {
-    if (!global.Olm) {
-        logger.warn('Not running megolm backup unit tests: libolm not present');
-        return;
-    }
-
-    beforeAll(function() {
-        return Olm.init();
-    });
-
-    let olmDevice;
-    let mockOlmLib;
-    let mockCrypto;
-    let cryptoStore;
-    let megolmDecryption;
-    beforeEach(async function() {
-        mockCrypto = testUtils.mock(Crypto, 'Crypto');
-        mockCrypto.backupManager = testUtils.mock(BackupManager, "BackupManager");
-        mockCrypto.backupKey = new Olm.PkEncryption();
-        mockCrypto.backupKey.set_recipient_key(
-            "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-        );
-        mockCrypto.backupInfo = CURVE25519_BACKUP_INFO;
-
-        cryptoStore = new MemoryCryptoStore();
-
-        olmDevice = new OlmDevice(cryptoStore);
-
-        // we stub out the olm encryption bits
-        mockOlmLib = {};
-        mockOlmLib.ensureOlmSessionsForDevices = jest.fn();
-        mockOlmLib.encryptMessageForDevice =
-            jest.fn().mockResolvedValue(undefined);
-    });
-
-    describe("backup", function() {
-        let mockBaseApis;
-
-        beforeEach(function() {
-            mockBaseApis = {};
-
-            megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: mockBaseApis,
-                roomId: ROOM_ID,
-            });
-
-            megolmDecryption.olmlib = mockOlmLib;
-
-            // clobber the setTimeout function to run 100x faster.
-            // ideally we would use lolex, but we have no oportunity
-            // to tick the clock between the first try and the retry.
-            const realSetTimeout = global.setTimeout;
-            jest.spyOn(global, 'setTimeout').mockImplementation(function(f, n) {
-                return realSetTimeout(f!, n!/100);
-            });
-        });
-
-        afterEach(function() {
-            jest.spyOn(global, 'setTimeout').mockRestore();
-        });
-
-        it('automatically calls the key back up', function() {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-
-            // construct a fake decrypted key event via the use of a mocked
-            // 'crypto' implementation.
-            const event = new MatrixEvent({
-                type: 'm.room.encrypted',
-            });
-            event.getWireType = () => "m.room.encrypted";
-            event.getWireContent = () => {
-                return {
-                    algorithm: "m.olm.v1.curve25519-aes-sha2",
-                };
-            };
-            const decryptedData = {
-                clearEvent: {
-                    type: 'm.room_key',
-                    content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
-                        room_id: ROOM_ID,
-                        session_id: groupSession.session_id(),
-                        session_key: groupSession.session_key(),
-                    },
-                },
-                senderCurve25519Key: "SENDER_CURVE25519",
-                claimedEd25519Key: "SENDER_ED25519",
-            };
-
-            mockCrypto.decryptEvent = function() {
-                return Promise.resolve(decryptedData);
-            };
-            mockCrypto.cancelRoomKeyRequest = function() {};
-
-            mockCrypto.backupManager = {
-                backupGroupSession: jest.fn(),
-            };
-
-            return event.attemptDecryption(mockCrypto).then(() => {
-                return megolmDecryption.onRoomKeyEvent(event);
-            }).then(() => {
-                expect(mockCrypto.backupManager.backupGroupSession).toHaveBeenCalled();
-            });
-        });
-
-        it('sends backups to the server (Curve25519 version)', function() {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-            const ibGroupSession = new Olm.InboundGroupSession();
-            ibGroupSession.create(groupSession.session_key());
-
-            const client = makeTestClient(cryptoStore);
-
-            megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            });
-
-            megolmDecryption.olmlib = mockOlmLib;
-
-            return client.initCrypto()
-                .then(() => {
-                    return cryptoStore.doTxn(
-                        "readwrite",
-                        [cryptoStore.STORE_SESSION],
-                        (txn) => {
-                            cryptoStore.addEndToEndInboundGroupSession(
-                                "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                                groupSession.session_id(),
-                                {
-                                    forwardingCurve25519KeyChain: undefined,
-                                    keysClaimed: {
-                                        ed25519: "SENDER_ED25519",
-                                    },
-                                    room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
-                                },
-                                txn);
-                        });
-                })
-                .then(async () => {
-                    await client.enableKeyBackup({
-                        algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                        version: '1',
-                        auth_data: {
-                            public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-                        },
-                    });
-                    let numCalls = 0;
-                    return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function<T>(
-                            method, path, queryParams, data, opts,
-                        ): Promise<T> {
-                            ++numCalls;
-                            expect(numCalls).toBeLessThanOrEqual(1);
-                            if (numCalls >= 2) {
-                                // exit out of retry loop if there's something wrong
-                                reject(new Error("authedRequest called too many timmes"));
-                                return Promise.resolve({} as T);
-                            }
-                            expect(method).toBe("PUT");
-                            expect(path).toBe("/room_keys/keys");
-                            expect(queryParams.version).toBe('1');
-                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
-                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
-                                groupSession.session_id(),
-                            );
-                            resolve();
-                            return Promise.resolve({} as T);
-                        };
-                        client.crypto!.backupManager.backupGroupSession(
-                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                            groupSession.session_id(),
-                        );
-                    }).then(() => {
-                        expect(numCalls).toBe(1);
-                        client.stopClient();
-                    });
-                });
-        });
-
-        it('sends backups to the server (AES-256 version)', function() {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-            const ibGroupSession = new Olm.InboundGroupSession();
-            ibGroupSession.create(groupSession.session_key());
-
-            const client = makeTestClient(cryptoStore);
-
-            megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            });
-
-            megolmDecryption.olmlib = mockOlmLib;
-
-            return client.initCrypto()
-                .then(() => {
-                    return client.crypto!.storeSessionBackupPrivateKey(new Uint8Array(32));
-                })
-                .then(() => {
-                    return cryptoStore.doTxn(
-                        "readwrite",
-                        [cryptoStore.STORE_SESSION],
-                        (txn) => {
-                            cryptoStore.addEndToEndInboundGroupSession(
-                                "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                                groupSession.session_id(),
-                                {
-                                    forwardingCurve25519KeyChain: undefined,
-                                    keysClaimed: {
-                                        ed25519: "SENDER_ED25519",
-                                    },
-                                    room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
-                                },
-                                txn);
-                        });
-                })
-                .then(async () => {
-                    await client.enableKeyBackup({
-                        algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
-                        version: '1',
-                        auth_data: {
-                            iv: "PsCAtR7gMc4xBd9YS3A9Ow",
-                            mac: "ZSDsTFEZK7QzlauCLMleUcX96GQZZM7UNtk4sripSqQ",
-                        },
-                    });
-                    let numCalls = 0;
-                    return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function<T>(
-                            method, path, queryParams, data, opts,
-                        ): Promise<T> {
-                            ++numCalls;
-                            expect(numCalls).toBeLessThanOrEqual(1);
-                            if (numCalls >= 2) {
-                                // exit out of retry loop if there's something wrong
-                                reject(new Error("authedRequest called too many timmes"));
-                                return Promise.resolve({} as T);
-                            }
-                            expect(method).toBe("PUT");
-                            expect(path).toBe("/room_keys/keys");
-                            expect(queryParams.version).toBe('1');
-                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
-                            expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
-                                groupSession.session_id(),
-                            );
-                            resolve();
-                            return Promise.resolve({} as T);
-                        };
-                        client.crypto!.backupManager.backupGroupSession(
-                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                            groupSession.session_id(),
-                        );
-                    }).then(() => {
-                        expect(numCalls).toBe(1);
-                        client.stopClient();
-                    });
-                });
-        });
-
-        it('signs backups with the cross-signing master key', async function() {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-            const ibGroupSession = new Olm.InboundGroupSession();
-            ibGroupSession.create(groupSession.session_key());
-
-            const client = makeTestClient(cryptoStore);
-
-            megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            });
-
-            megolmDecryption.olmlib = mockOlmLib;
-
-            await client.initCrypto();
-            client.uploadDeviceSigningKeys = async function(e) {return {};};
-            client.uploadKeySignatures = async function(e) {return { failures: {} };};
-            await resetCrossSigningKeys(client);
-            let numCalls = 0;
-            await Promise.all([
-                new Promise<void>((resolve, reject) => {
-                    let backupInfo;
-                    client.http.authedRequest = function(
-                        method, path, queryParams, data, opts,
-                    ) {
-                        ++numCalls;
-                        expect(numCalls).toBeLessThanOrEqual(2);
-                        if (numCalls === 1) {
-                            expect(method).toBe("POST");
-                            expect(path).toBe("/room_keys/version");
-                            try {
-                                // make sure auth_data is signed by the master key
-                                olmlib.pkVerify(
-                                    (data as Record<string, any>).auth_data, client.getCrossSigningId()!, "@alice:bar",
-                                );
-                            } catch (e) {
-                                reject(e);
-                                return Promise.resolve({});
-                            }
-                            backupInfo = data;
-                            return Promise.resolve({});
-                        } else if (numCalls === 2) {
-                            expect(method).toBe("GET");
-                            expect(path).toBe("/room_keys/version");
-                            resolve();
-                            return Promise.resolve(backupInfo);
-                        } else {
-                            // exit out of retry loop if there's something wrong
-                            reject(new Error("authedRequest called too many times"));
-                            return Promise.resolve({});
-                        }
-                    };
-                }),
-                client.createKeyBackupVersion({
-                    algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                    auth_data: {
-                        public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-                    },
-                }),
-            ]);
-            expect(numCalls).toBe(2);
-            client.stopClient();
-        });
-
-        it('retries when a backup fails', async function() {
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-            const ibGroupSession = new Olm.InboundGroupSession();
-            ibGroupSession.create(groupSession.session_key());
-
-            const scheduler = [
-                "getQueueForEvent", "queueEvent", "removeEventFromQueue",
-                "setProcessFunction",
-            ].reduce((r, k) => {r[k] = jest.fn(); return r;}, {}) as MockedObject<MatrixScheduler>;
-            const store = new StubStore();
-            const client = new MatrixClient({
-                baseUrl: "https://my.home.server",
-                idBaseUrl: "https://identity.server",
-                accessToken: "my.access.token",
-                fetchFn: jest.fn(), // NOP
-                store: store,
-                scheduler: scheduler,
-                userId: "@alice:bar",
-                deviceId: "device",
-                cryptoStore: cryptoStore,
-            });
-
-            megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            });
-
-            megolmDecryption.olmlib = mockOlmLib;
-
-            await client.initCrypto();
-            await cryptoStore.doTxn(
-                "readwrite",
-                [cryptoStore.STORE_SESSION],
-                (txn) => {
-                    cryptoStore.addEndToEndInboundGroupSession(
-                        "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                        groupSession.session_id(),
-                        {
-                            forwardingCurve25519KeyChain: undefined,
-                            keysClaimed: {
-                                ed25519: "SENDER_ED25519",
-                            },
-                            room_id: ROOM_ID,
-                            session: ibGroupSession.pickle(olmDevice.pickleKey),
-                        },
-                        txn);
-                });
-
-            await client.enableKeyBackup({
-                algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                version: '1',
-                auth_data: {
-                    public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-                },
-            });
-            let numCalls = 0;
-
-            await new Promise<void>((resolve, reject) => {
-                client.http.authedRequest = function<T>(
-                    method, path, queryParams, data, opts,
-                ): Promise<T> {
-                    ++numCalls;
-                    expect(numCalls).toBeLessThanOrEqual(2);
-                    if (numCalls >= 3) {
-                        // exit out of retry loop if there's something wrong
-                        reject(new Error("authedRequest called too many timmes"));
-                        return Promise.resolve({} as T);
-                    }
-                    expect(method).toBe("PUT");
-                    expect(path).toBe("/room_keys/keys");
-                    expect(queryParams.version).toBe('1');
-                    expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
-                    expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
-                        groupSession.session_id(),
-                    );
-                    if (numCalls > 1) {
-                        resolve();
-                        return Promise.resolve({} as T);
-                    } else {
-                        return Promise.reject(
-                            new Error("this is an expected failure"),
-                        );
-                    }
-                };
-                return client.crypto!.backupManager.backupGroupSession(
-                    "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                    groupSession.session_id(),
-                );
-            });
-            expect(numCalls).toBe(2);
-            client.stopClient();
-        });
-    });
-
-    describe("restore", function() {
-        let client;
-
-        beforeEach(function() {
-            client = makeTestClient(cryptoStore);
-
-            megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: client,
-                roomId: ROOM_ID,
-            });
-
-            megolmDecryption.olmlib = mockOlmLib;
-
-            return client.initCrypto();
-        });
-
-        afterEach(function() {
-            client.stopClient();
-        });
-
-        it('can restore from backup (Curve25519 version)', function() {
-            client.http.authedRequest = function() {
-                return Promise.resolve(CURVE25519_KEY_BACKUP_DATA);
-            };
-            return client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                ROOM_ID,
-                SESSION_ID,
-                CURVE25519_BACKUP_INFO,
-            ).then(() => {
-                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-            }).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-                expect(res.untrusted).toBeTruthy(); // keys from Curve25519 backup are untrusted
-            });
-        });
-
-        it('can restore from backup (AES-256 version)', function() {
-            client.http.authedRequest = function() {
-                return Promise.resolve(AES256_KEY_BACKUP_DATA);
-            };
-            return client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                ROOM_ID,
-                SESSION_ID,
-                AES256_BACKUP_INFO,
-            ).then(() => {
-                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-            }).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-                expect(res.untrusted).toBeFalsy(); // keys from AES backup are trusted
-            });
-        });
-
-        it('can restore backup by room (Curve25519 version)', function() {
-            client.http.authedRequest = function() {
-                return Promise.resolve({
-                    rooms: {
-                        [ROOM_ID]: {
-                            sessions: {
-                                [SESSION_ID]: CURVE25519_KEY_BACKUP_DATA,
-                            },
-                        },
-                    },
-                });
-            };
-            return client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                null, null, CURVE25519_BACKUP_INFO,
-            ).then(() => {
-                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-            }).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-            });
-        });
-
-        it('has working cache functions', async function() {
-            const key = Uint8Array.from([1, 2, 3, 4, 5, 6, 7, 8]);
-            await client.crypto.storeSessionBackupPrivateKey(key);
-            const result = await client.crypto.getSessionBackupPrivateKey();
-            expect(new Uint8Array(result)).toEqual(key);
-        });
-
-        it('caches session backup keys as it encounters them', async function() {
-            const cachedNull = await client.crypto.getSessionBackupPrivateKey();
-            expect(cachedNull).toBeNull();
-            client.http.authedRequest = function() {
-                return Promise.resolve(CURVE25519_KEY_BACKUP_DATA);
-            };
-            await new Promise((resolve) => {
-                client.restoreKeyBackupWithRecoveryKey(
-                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                    ROOM_ID,
-                    SESSION_ID,
-                    CURVE25519_BACKUP_INFO,
-                    { cacheCompleteCallback: resolve },
-                );
-            });
-            const cachedKey = await client.crypto.getSessionBackupPrivateKey();
-            expect(cachedKey).not.toBeNull();
-        });
-
-        it("fails if an known algorithm is used", async function() {
-            const BAD_BACKUP_INFO = Object.assign({}, CURVE25519_BACKUP_INFO, {
-                algorithm: "this.algorithm.does.not.exist",
-            });
-            client.http.authedRequest = function() {
-                return Promise.resolve(CURVE25519_KEY_BACKUP_DATA);
-            };
-
-            await expect(client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                ROOM_ID,
-                SESSION_ID,
-                BAD_BACKUP_INFO,
-            )).rejects.toThrow();
-        });
-    });
-
-    describe("flagAllGroupSessionsForBackup", () => {
-        it("should return number of sesions needing backup", async () => {
-            const scheduler = [
-                "getQueueForEvent", "queueEvent", "removeEventFromQueue",
-                "setProcessFunction",
-            ].reduce((r, k) => {r[k] = jest.fn(); return r;}, {}) as MockedObject<MatrixScheduler>;
-            const store = new StubStore();
-            const client = new MatrixClient({
-                baseUrl: "https://my.home.server",
-                idBaseUrl: "https://identity.server",
-                accessToken: "my.access.token",
-                fetchFn: jest.fn(), // NOP
-                store,
-                scheduler,
-                userId: "@alice:bar",
-                deviceId: "device",
-                cryptoStore,
-            });
-            await client.initCrypto();
-
-            cryptoStore.countSessionsNeedingBackup = jest.fn().mockReturnValue(6);
-            await expect(client.flagAllGroupSessionsForBackup()).resolves.toBe(6);
-            client.stopClient();
-        });
-    });
-});
@@ -1,45 +0,0 @@
-import { IRecoveryKey } from '../../../src/crypto/api';
-import { CrossSigningLevel } from '../../../src/crypto/CrossSigning';
-import { IndexedDBCryptoStore } from '../../../src/crypto/store/indexeddb-crypto-store';
-
-// needs to be phased out and replaced with bootstrapSecretStorage,
-// but that is doing too much extra stuff for it to be an easy transition.
-export async function resetCrossSigningKeys(
-    client,
-    { level }: { level?: CrossSigningLevel} = {},
-): Promise<void> {
-    const crypto = client.crypto;
-
-    const oldKeys = Object.assign({}, crypto.crossSigningInfo.keys);
-    try {
-        await crypto.crossSigningInfo.resetKeys(level);
-        await crypto.signObject(crypto.crossSigningInfo.keys.master);
-        // write a copy locally so we know these are trusted keys
-        await crypto.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                crypto.cryptoStore.storeCrossSigningKeys(
-                    txn, crypto.crossSigningInfo.keys);
-            },
-        );
-    } catch (e) {
-        // If anything failed here, revert the keys so we know to try again from the start
-        // next time.
-        crypto.crossSigningInfo.keys = oldKeys;
-        throw e;
-    }
-    crypto.emit("crossSigning.keysChanged", {});
-    await crypto.afterCrossSigningLocalKeyChange();
-}
-
-export async function createSecretStorageKey(): Promise<IRecoveryKey> {
-    const decryption = new global.Olm.PkDecryption();
-    const storagePublicKey = decryption.generate_key();
-    const storagePrivateKey = decryption.get_private_key();
-    decryption.free();
-    return {
-        // `pubkey` not used anymore with symmetric 4S
-        keyInfo: { pubkey: storagePublicKey, key: undefined! },
-        privateKey: storagePrivateKey,
-    };
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
David Baker	a600432946	v0.14.3	2019-01-22 10:41:09 +00:00
David Baker	cde77cfc92	Prepare changelog for v0.14.3	2019-01-22 10:41:08 +00:00
David Baker	d1f8cbaade	v0.14.3-rc.1	2019-01-17 10:44:15 +00:00
David Baker	5f29cd2c1c	Prepare changelog for v0.14.3-rc.1	2019-01-17 10:44:14 +00:00