v15.0.0-rc.1

Try to answer a call without video if we can't access the camera

.eslintrc.js

@@ -1,71 +1,16 @@
 module.exports = {
-    parser: "babel-eslint", // now needed for class properties
-    parserOptions: {
-        sourceType: "module",
-        ecmaFeatures: {
-        }
-    },
+    plugins: [
+        "matrix-org",
+    ],
+    extends: [
+        "plugin:matrix-org/babel",
+    ],
     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,
-        jest: true,
     },
-    extends: ["eslint:recommended", "google"],
-    plugins: [
-        "babel",
-        "jest",
-    ],
     rules: {
-        // 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"],
-        "guard-for-in": ["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"],
@@ -79,10 +24,35 @@ module.exports = {
             "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",
+    },
+    overrides: [{
+        files: [
+            "**/*.ts",
+        ],
+        extends: [
+            "plugin:matrix-org/typescript",
+        ],
+        rules: {
+            // TypeScript has its own version of this
+            "@babel/no-invalid-this": "off",
 
-        // eslint's built in no-invalid-this rule breaks with class properties
-        "no-invalid-this": "off",
-        // so we replace it with a version that is class property aware
-        "babel/no-invalid-this": "error",
-    }
-}
+            // 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",
+
+            "quotes": "off",
+            // We use a `logger` intermediary module
+            "no-console": "error",
+        },
+    }],
+};

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @matrix-org/element-web

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,7 @@
+<!-- Please read https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md before submitting your pull request -->
+
+<!-- Include a Sign-Off as described in https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md#sign-off -->
+
+<!-- To specify text for the changelog entry (otherwise the PR title will be used):
+Notes:
+-->

.github/workflows/preview_changelog.yaml

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

.gitignore

@@ -12,8 +12,10 @@ lib-cov
 out
 /dist
 /lib
-/specbuild
 
 # version file and tarball created by `npm pack` / `yarn pack`
 /git-revision.txt
 /matrix-js-sdk-*.tgz
+
+.vscode
+.vscode/

CONTRIBUTING.md

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

CONTRIBUTING.rst

@@ -1,132 +0,0 @@
-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 js-sdk aims to target TypeScript/ES6. All new files should be written in
-TypeScript and existing files should use ES6 principles where possible.
-
-Members should not be exported as a default export in general - it causes problems
-with the architecture of the SDK (index file becomes less clear) and could
-introduce naming problems (as default exports get aliased upon import). In
-general, avoid using `export default`.
-
-The remaining code-style for matrix-js-sdk is not formally documented, but
-contributors are encouraged to read the code style document for matrix-react-sdk
-(`<https://github.com/matrix-org/matrix-react-sdk/blob/master/code_style.md>`_)
-and follow the principles set out there.
-
-Please ensure your changes match the cosmetic style of the existing project,
-and **never** mix cosmetic and functional changes in the same commit, as it
-makes it horribly hard to review otherwise.
-
-Attribution
-~~~~~~~~~~~
-
-Everyone who contributes anything to Matrix is welcome to be listed in the
-AUTHORS.rst file for the project in question. Please feel free to include a
-change to AUTHORS.rst in your pull request to list yourself and a short
-description of the area(s) you've worked on. Also, we sometimes have swag to
-give away to contributors - if you feel that Matrix-branded apparel is missing
-from your life, please mail us your shipping address to matrix at matrix.org
-and we'll try to fix it :)
-
-Sign off
-~~~~~~~~
-
-In order to have a concrete record that your contribution is intentional
-and you agree to license it under the same terms as the project's license, we've
-adopted the same lightweight approach that the Linux Kernel
-(https://www.kernel.org/doc/Documentation/SubmittingPatches), Docker
-(https://github.com/docker/docker/blob/master/CONTRIBUTING.md), and many other
-projects use: the DCO (Developer Certificate of Origin:
-http://developercertificate.org/). This is a simple declaration that you wrote
-the contribution or otherwise have the right to contribute it to Matrix::
-
-    Developer Certificate of Origin
-    Version 1.1
-
-    Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
-    660 York Street, Suite 102,
-    San Francisco, CA 94110 USA
-
-    Everyone is permitted to copy and distribute verbatim copies of this
-    license document, but changing it is not allowed.
-
-    Developer's Certificate of Origin 1.1
-
-    By making a contribution to this project, I certify that:
-
-    (a) The contribution was created in whole or in part by me and I
-        have the right to submit it under the open source license
-        indicated in the file; or
-
-    (b) The contribution is based upon previous work that, to the best
-        of my knowledge, is covered under an appropriate open source
-        license and I have the right under that license to submit that
-        work with modifications, whether created in whole or in part
-        by me, under the same open source license (unless I am
-        permitted to submit under a different license), as indicated
-        in the file; or
-
-    (c) The contribution was provided directly to me by some other
-        person who certified (a), (b) or (c) and I have not modified
-        it.
-
-    (d) I understand and agree that this project and the contribution
-        are public and that a record of the contribution (including all
-        personal information I submit with it, including my sign-off) is
-        maintained indefinitely and may be redistributed consistent with
-        this project or the open source license(s) involved.
-
-If you agree to this for your contribution, then all that's needed is to
-include the line in your commit or pull request comment::
-
-    Signed-off-by: Your Name <your@email.example.org>
-
-We accept contributions under a legally identifiable name, such as your name on
-government documentation or common-law names (names claimed by legitimate usage
-or repute). Unfortunately, we cannot accept anonymous contributions at this
-time.
-
-Git allows you to add this signoff automatically when using the ``-s`` flag to
-``git commit``, which uses the name and email set in your ``user.name`` and
-``user.email`` git configs.
-
-If you forgot to sign off your commits before making your pull request and are
-on Git 2.17+ you can mass signoff using rebase::
-
-    git rebase --signoff origin/develop

README.md

@@ -30,7 +30,7 @@ This SDK targets Node 10 for compatibility, which translates to ES6. If you're u
 a bundler like webpack you'll likely have to transpile dependencies, including this
 SDK, to match your target browsers.
 
-Using `yarn` instead of `npm` is recommended. Please see the Yarn [install guide](https://yarnpkg.com/docs/install/) 
+Using `yarn` instead of `npm` is recommended. Please see the Yarn [install guide](https://classic.yarnpkg.com/en/docs/install) 
 if you do not have it already.
 
 ``yarn add matrix-js-sdk``
@@ -182,10 +182,8 @@ 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 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.
+The main thing to note is that it is problematic to discard the result of a
+promise-returning function, as that will cause exceptions to go unobserved.
 
 Methods which return a promise show this in their documentation.
 
@@ -309,7 +307,7 @@ 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.
 
-It is also necessry to call ``matrixClient.initCrypto()`` after creating a new
+It is also necessary to call ``matrixClient.initCrypto()`` after creating a new
 ``MatrixClient`` (but **before** calling ``matrixClient.startClient()``) to
 initialise the crypto layer.
 

examples/browser/browserTest.js

@@ -1,6 +1,6 @@
 console.log("Loading browser sdk");
 
-var client = matrixcs.createClient("http://matrix.org");
+var client = matrixcs.createClient("https://matrix.org");
 client.publicRooms(function (err, data) {
     if (err) {
 	   console.error("err %s", JSON.stringify(err));

examples/browser/index.html

@@ -1,6 +1,8 @@
-<html>
+<html lang="en">
 <head>
 <title>Test</title>
+<meta charset="utf-8"/>
+<link rel="icon" href="data:,">
 <script src="lib/matrix.js"></script>
 <script src="browserTest.js"></script>
 </head>

examples/node/app.js

@@ -288,7 +288,7 @@ function printMemberList(room) {
 }
 
 function printRoomInfo(room) {
-    var eventDict = room.currentState.events;
+    var eventMap = room.currentState.events;
     var eTypeHeader = "    Event Type(state_key)    ";
     var sendHeader = "        Sender        ";
     // pad content to 100
@@ -300,14 +300,15 @@ function printRoomInfo(room) {
     var contentHeader = padSide + "Content" + padSide;
     print(eTypeHeader+sendHeader+contentHeader);
     print(new Array(100).join("-"));
-    Object.keys(eventDict).forEach(function(eventType) {
+    eventMap.keys().forEach(function(eventType) {
         if (eventType === "m.room.member") { return; } // use /members instead.
-        Object.keys(eventDict[eventType]).forEach(function(stateKey) {
+        var eventEventMap = eventMap.get(eventType);
+        eventEventMap.keys().forEach(function(stateKey) {
             var typeAndKey = eventType + (
                 stateKey.length > 0 ? "("+stateKey+")" : ""
             );
             var typeStr = fixWidth(typeAndKey, eTypeHeader.length);
-            var event = eventDict[eventType][stateKey];
+            var event = eventEventMap.get(stateKey);
             var sendStr = fixWidth(event.getSender(), sendHeader.length);
             var contentStr = fixWidth(
                 JSON.stringify(event.getContent()), contentHeader.length

examples/voip/browserTest.js

@@ -31,6 +31,23 @@ 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() {
@@ -62,10 +79,7 @@ function syncComplete() {
         );
         console.log("Call => %s", call);
         addListeners(call);
-        call.placeVideoCall(
-            document.getElementById("remote"),
-            document.getElementById("local")
-        );
+        call.placeVideoCall();
         document.getElementById("result").innerHTML = "<p>Placed call.</p>";
         disableButtons(true, true, false);
     };

examples/voip/index.html

@@ -1,26 +1,34 @@
 <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">
-        <div id="videoContainer">
-            <video id="remote"></video>
-        </div>
-    </div>
-    <div id="videoBackground">
-        <div id="videoContainer">
-            <video id="local"></video>
-        </div>
+    <div id="videoBackground" class="video-background">
+        <video class="video-element" id="local"></video>
+        <video class="video-element" id="remote"></video>
     </div>
 </body>
+
 </html>
+
+<style>
+    .video-background {
+        height: 500px;
+        margin: 10px;
+    }
+
+    .video-element {
+        height: 100%;
+    }
+</style>

jsdoc.json

@@ -18,6 +18,13 @@
     "readme": "README.md",
     "recurse": true,
     "verbose": true,
-    "template": "node_modules/better-docs"
+    "template": "node_modules/docdash"
+  },
+  "docdash": {
+    "static": true,
+    "private": false,
+    "search": true,
+    "collapse": true,
+    "typedefs": true
   }
 }

package.json

@@ -1,24 +1,26 @@
 {
   "name": "matrix-js-sdk",
-  "version": "5.2.0",
+  "version": "15.0.0-rc.1",
   "description": "Matrix Client-Server SDK for Javascript",
   "scripts": {
-    "prepare": "yarn build",
+    "prepublishOnly": "yarn build",
     "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
     "dist": "echo 'This is for the release script so it can make assets (browser bundle).' && yarn build",
     "clean": "rimraf lib dist",
-    "build": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:compile-browser && yarn build:minify-browser && yarn build:types",
-    "build:types": "tsc --emitDeclarationOnly",
+    "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.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
+    "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:ts && yarn lint:js",
-    "lint:js": "eslint --max-warnings 93 src spec",
+    "lint": "yarn lint:types && yarn lint:js",
+    "lint:js": "eslint --max-warnings 7 src spec",
+    "lint:js-fix": "eslint --fix src spec",
     "lint:types": "tsc --noEmit",
-    "lint:ts": "tslint --project ./tsconfig.json -t stylish",
-    "test": "jest spec/ --coverage --testEnvironment node",
-    "test:watch": "jest spec/ --coverage --testEnvironment node --watch"
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "coverage": "yarn test --coverage"
   },
   "repository": {
     "type": "git",
@@ -28,13 +30,15 @@
     "matrix-org"
   ],
   "main": "./lib/index.js",
-  "typings": "./lib/index.d.ts",
   "browser": "./lib/browser-index.js",
   "matrix_src_main": "./src/index.ts",
   "matrix_src_browser": "./src/browser-index.js",
+  "matrix_lib_main": "./lib/index.js",
+  "matrix_lib_typings": "./lib/index.d.ts",
   "author": "matrix.org",
   "license": "Apache-2.0",
   "files": [
+    "dist",
     "lib",
     "src",
     "git-revision.txt",
@@ -46,51 +50,68 @@
     "release.sh"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.8.3",
+    "@babel/runtime": "^7.12.5",
     "another-json": "^0.2.0",
     "browser-request": "^0.3.3",
     "bs58": "^4.0.1",
-    "content-type": "^1.0.2",
-    "loglevel": "^1.6.4",
-    "qs": "^6.5.2",
-    "request": "^2.88.0",
-    "unhomoglyph": "^1.0.2"
+    "content-type": "^1.0.4",
+    "loglevel": "^1.7.1",
+    "p-retry": "^4.5.0",
+    "qs": "^6.9.6",
+    "request": "^2.88.2",
+    "unhomoglyph": "^1.0.6"
   },
   "devDependencies": {
-    "@babel/cli": "^7.7.5",
-    "@babel/core": "^7.7.5",
-    "@babel/plugin-proposal-class-properties": "^7.7.4",
-    "@babel/plugin-proposal-numeric-separator": "^7.7.4",
-    "@babel/plugin-proposal-object-rest-spread": "^7.7.4",
-    "@babel/plugin-syntax-dynamic-import": "^7.7.4",
-    "@babel/plugin-transform-runtime": "^7.8.3",
-    "@babel/preset-env": "^7.7.6",
-    "@babel/preset-typescript": "^7.7.4",
-    "@babel/register": "^7.7.4",
+    "@babel/cli": "^7.12.10",
+    "@babel/core": "^7.12.10",
+    "@babel/eslint-parser": "^7.12.10",
+    "@babel/eslint-plugin": "^7.12.10",
+    "@babel/plugin-proposal-class-properties": "^7.12.1",
+    "@babel/plugin-proposal-numeric-separator": "^7.12.7",
+    "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-runtime": "^7.12.10",
+    "@babel/preset-env": "^7.12.11",
+    "@babel/preset-typescript": "^7.12.7",
+    "@babel/register": "^7.12.10",
+    "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.3.tgz",
+    "@types/bs58": "^4.0.1",
+    "@types/jest": "^26.0.20",
     "@types/node": "12",
-    "babel-eslint": "^10.0.3",
-    "babel-jest": "^24.9.0",
+    "@types/request": "^2.48.5",
+    "@typescript-eslint/eslint-plugin": "^4.17.0",
+    "@typescript-eslint/parser": "^4.17.0",
+    "allchange": "^1.0.2",
+    "babel-jest": "^26.6.3",
     "babelify": "^10.0.0",
-    "better-docs": "^1.4.7",
-    "browserify": "^16.5.0",
-    "eslint": "^5.12.0",
-    "eslint-config-google": "^0.7.1",
-    "eslint-plugin-babel": "^5.3.0",
-    "eslint-plugin-jest": "^23.0.4",
+    "better-docs": "^2.4.0-beta.9",
+    "browserify": "^17.0.0",
+    "docdash": "^1.2.0",
+    "eslint": "7.18.0",
+    "eslint-config-google": "^0.14.0",
+    "eslint-plugin-matrix-org": "github:matrix-org/eslint-plugin-matrix-org#2306b3d4da4eba908b256014b979f1d3d43d2945",
     "exorcist": "^1.0.1",
-    "fake-indexeddb": "^3.0.0",
-    "jest": "^24.9.0",
-    "jest-localstorage-mock": "^2.4.0",
-    "jsdoc": "^3.5.5",
+    "fake-indexeddb": "^3.1.2",
+    "jest": "^26.6.3",
+    "jest-localstorage-mock": "^2.4.6",
+    "jsdoc": "^3.6.6",
     "matrix-mock-request": "^1.2.3",
-    "olm": "https://packages.matrix.org/npm/olm/olm-3.1.4.tgz",
-    "rimraf": "^3.0.0",
-    "terser": "^4.4.3",
-    "tsify": "^4.0.1",
-    "tslint": "^5.20.1",
-    "typescript": "^3.7.3"
+    "rimraf": "^3.0.2",
+    "terser": "^5.5.1",
+    "tsify": "^5.0.2",
+    "typescript": "^4.1.3"
   },
   "jest": {
-    "testEnvironment": "node"
-  }
+    "testEnvironment": "node",
+    "testMatch": [
+      "<rootDir>/spec/**/*.spec.{js,ts}"
+    ],
+    "collectCoverageFrom": [
+      "<rootDir>/src/**/*.{js,ts}"
+    ],
+    "coverageReporters": [
+      "text"
+    ]
+  },
+  "typings": "./lib/index.d.ts"
 }

release.sh

@@ -10,7 +10,7 @@
 #   npm; typically installed by Node.js
 #   yarn; install via brew (macOS) or similar (https://yarnpkg.com/docs/install/)
 #
-# Note: this script is also used to release matrix-react-sdk and riot-web.
+# Note: this script is also used to release matrix-react-sdk and element-web.
 
 set -e
 
@@ -38,6 +38,7 @@ $USAGE
     -c changelog_file:  specify name of file containing changelog
     -x:                 skip updating the changelog
     -z:                 skip generating the jsdoc
+    -n:                 skip publish to NPM
 EOF
 }
 
@@ -60,9 +61,10 @@ fi
 
 skip_changelog=
 skip_jsdoc=
+skip_npm=
 changelog_file="CHANGELOG.md"
 expected_npm_user="matrixdotorg"
-while getopts hc:u:xz f; do
+while getopts hc:u:xzn f; do
     case $f in
         h)
             help
@@ -77,6 +79,9 @@ while getopts hc:u:xz f; do
         z)
             skip_jsdoc=1
             ;;
+        n)
+            skip_npm=1
+            ;;
         u)
             expected_npm_user="$OPTARG"
             ;;
@@ -89,17 +94,22 @@ if [ $# -ne 1 ]; then
     exit 1
 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
+# We use Git branch / commit dependencies for some packages, and Yarn seems
+# to have a hard time getting that right. See also
+# https://github.com/yarnpkg/yarn/issues/4734. As a workaround, we clean the
+# global cache here to ensure we get the right thing.
+yarn cache clean
+# Ensure all dependencies are updated
+yarn install --ignore-scripts --pure-lockfile
 
 # Login and publish continues to use `npm`, as it seems to have more clearly
 # defined options and semantics than `yarn` for writing to the registry.
-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
+if [ -z "$skip_npm" ]; then
+    actual_npm_user=`npm whoami`;
+    if [ $expected_npm_user != $actual_npm_user ]; then
+        echo "you need to be logged into npm as $expected_npm_user, but you are logged in as $actual_npm_user" >&2
+        exit 1
+    fi
 fi
 
 # ignore leading v on release
@@ -118,14 +128,6 @@ if [ $prerelease -eq 1 ]; then
     echo Making a PRE-RELEASE
 fi
 
-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
@@ -141,7 +143,7 @@ fi
 
 if [ -z "$skip_changelog" ]; then
     echo "Generating changelog"
-    update_changelog -f "$changelog_file" "$release"
+    yarn run allchange "$release"
     read -p "Edit $changelog_file manually, or press enter to continue " REPLY
 
     if [ -n "$(git ls-files --modified $changelog_file)" ]; then
@@ -163,6 +165,19 @@ echo "yarn version"
 # 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
@@ -176,7 +191,10 @@ git commit package.json $pkglock -m "$tag"
 # figure out if we should be signing this release
 signing_id=
 if [ -f release_config.yaml ]; then
-    signing_id=`cat release_config.yaml | python -c "import yaml; import sys; print yaml.load(sys.stdin)['signing_id']"`
+    result=`cat release_config.yaml | python -c "import yaml; import sys; print yaml.load(sys.stdin)['signing_id']" 2> /dev/null || true`
+    if [ "$?" -eq 0 ]; then
+        signing_id=$result
+    fi
 fi
 
 
@@ -197,12 +215,7 @@ if [ $dodist -eq 0 ]; then
     pushd "$builddir"
     git clone "$projdir" .
     git checkout "$rel_branch"
-    # 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
-    yarn install
+    yarn install --pure-lockfile
     # We haven't tagged yet, so tell the dist script what version
     # it's building
     DIST_VERSION="$tag" yarn dist
@@ -298,11 +311,13 @@ rm "${latest_changes}"
 # defined options and semantics than `yarn` for writing to the registry.
 # Tag both releases and prereleases as `next` so the last stable release remains
 # the default.
-npm publish --tag next
-if [ $prerelease -eq 0 ]; then
-    # For a release, also add the default `latest` tag.
-    package=$(cat package.json | jq -er .name)
-    npm dist-tag add "$package@$release" latest
+if [ -z "$skip_npm" ]; then
+    npm publish --tag next
+    if [ $prerelease -eq 0 ]; then
+        # For a release, also add the default `latest` tag.
+        package=$(cat package.json | jq -er .name)
+        npm dist-tag add "$package@$release" latest
+    fi
 fi
 
 if [ -z "$skip_jsdoc" ]; then
@@ -318,6 +333,7 @@ if [ -z "$skip_jsdoc" ]; then
         $release index.html
     git add "$release"
     git commit --no-verify -m "Add jsdoc for $release" index.html "$release"
+    git push origin gh-pages
 fi
 
 # if it is a pre-release, leave it on the release branch for now.
@@ -330,16 +346,40 @@ fi
 echo "updating master branch"
 git checkout master
 git pull
-git merge "$rel_branch"
+git merge "$rel_branch" --no-edit
 
-# push master and docs (if generated) to github
+# push master to github
 git push origin master
-if [ -z "$skip_jsdoc" ]; then
-    git push origin gh-pages
-fi
 
-# finally, merge master back onto develop
-git checkout develop
-git pull
-git merge master
-git push origin develop
+# finally, merge master back onto develop (if it exists)
+if [ $(git branch -lr | grep origin/develop -c) -ge 1 ]; then
+    git checkout develop
+    git pull
+    git merge master --no-edit
+
+    # When merging to develop, we need revert the `main` and `typings` fields if
+    # we adjusted them previously.
+    for i in main typings
+    do
+        # If a `lib` prefixed value is present, it means we adjusted the field
+        # earlier at publish time, so we should revert it now.
+        if [ "$(jq -r ".matrix_lib_$i" package.json)" != "null" ]; then
+            # If there's a `src` prefixed value, use that, otherwise delete.
+            # This is used to delete the `typings` field and reset `main` back
+            # to the TypeScript source.
+            src_value=$(jq -r ".matrix_src_$i" package.json)
+            if [ "$src_value" != "null" ]; then
+                jq ".$i = .matrix_src_$i" package.json > package.json.new && mv package.json.new package.json
+            else
+                jq "del(.$i)" package.json > package.json.new && mv package.json.new package.json
+            fi
+        fi
+    done
+
+    if [ -n "$(git ls-files --modified package.json)" ]; then
+        echo "Committing develop package.json"
+        git commit package.json -m "Resetting package fields for development"
+    fi
+
+    git push origin develop
+fi

spec/MockBlob.ts

@@ -0,0 +1,27 @@
+/*
+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.
+*/
+
+export class MockBlob {
+    private contents: number[] = [];
+
+    public constructor(private parts: ArrayLike<number>[]) {
+        parts.forEach(p => Array.from(p).forEach(e => this.contents.push(e)));
+    }
+
+    public get size(): number {
+        return this.contents.length;
+    }
+}

spec/TestClient.js

@@ -20,12 +20,12 @@ limitations under the License.
 import './olm-loader';
 
 import MockHttpBackend from 'matrix-mock-request';
-import {LocalStorageCryptoStore} from '../src/crypto/store/localStorage-crypto-store';
-import {logger} from '../src/logger';
-import {WebStorageSessionStore} from "../src/store/session/webstorage";
-import {syncPromise} from "./test-utils";
-import {createClient} from "../src/matrix";
-import {MockStorageApi} from "./MockStorageApi";
+import { LocalStorageCryptoStore } from '../src/crypto/store/localStorage-crypto-store';
+import { logger } from '../src/logger';
+import { WebStorageSessionStore } from "../src/store/session/webstorage";
+import { syncPromise } from "./test-utils";
+import { createClient } from "../src/matrix";
+import { MockStorageApi } from "./MockStorageApi";
 
 /**
  * Wrapper for a MockStorageApi, MockHttpBackend and MatrixClient
@@ -69,6 +69,9 @@ export function TestClient(
 
     this.deviceKeys = null;
     this.oneTimeKeys = {};
+    this.callEventHandler = {
+        calls: new Map(),
+    };
 }
 
 TestClient.prototype.toString = function() {
@@ -126,11 +129,10 @@ TestClient.prototype.expectDeviceKeyUpload = function() {
         expect(Object.keys(self.oneTimeKeys).length).toEqual(0);
 
         self.deviceKeys = content.device_keys;
-        return {one_time_key_counts: {signed_curve25519: 0}};
+        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
@@ -148,9 +150,9 @@ TestClient.prototype.awaitOneTimeKeyUpload = function() {
         .respond(200, (path, content) => {
             expect(content.device_keys).toBe(undefined);
             expect(content.one_time_keys).toBe(undefined);
-            return {one_time_key_counts: {
+            return { one_time_key_counts: {
                 signed_curve25519: Object.keys(this.oneTimeKeys).length,
-            }};
+            } };
         });
 
     this.httpBackend.when("POST", "/keys/upload")
@@ -161,9 +163,9 @@ TestClient.prototype.awaitOneTimeKeyUpload = function() {
               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: {
+              return { one_time_key_counts: {
                   signed_curve25519: Object.keys(this.oneTimeKeys).length,
-              }};
+              } };
           });
 
     // this can take ages
@@ -185,7 +187,7 @@ TestClient.prototype.expectKeyQuery = function(response) {
         200, (path, content) => {
             Object.keys(response.device_keys).forEach((userId) => {
                 expect(content.device_keys[userId]).toEqual(
-                    {},
+                    [],
                     "Expected key query for " + userId + ", got " +
                     Object.keys(content.device_keys),
                 );
@@ -194,7 +196,6 @@ TestClient.prototype.expectKeyQuery = function(response) {
         });
 };
 
-
 /**
  * get the uploaded curve25519 device key
  *
@@ -205,7 +206,6 @@ TestClient.prototype.getDeviceKey = function() {
     return this.deviceKeys.keys[keyId];
 };
 
-
 /**
  * get the uploaded ed25519 device key
  *
@@ -230,3 +230,7 @@ TestClient.prototype.flushSync = function() {
         logger.log(`${this}: flushSync completed`);
     });
 };
+
+TestClient.prototype.isFallbackICEServerAllowed = function() {
+    return true;
+};

spec/browserify/setupTests.js

@@ -0,0 +1,23 @@
+/*
+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
+global.XMLHttpRequest = jest.fn();
+
+afterAll(() => {
+    // clean up XMLHttpRequest mock
+    global.XMLHttpRequest = undefined;
+});

spec/browserify/sync-browserify.spec.js

@@ -0,0 +1,103 @@
+/*
+Copyright 2020 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// load XmlHttpRequest mock
+import "./setupTests";
+import "../../dist/browser-matrix"; // uses browser-matrix instead of the src
+import { MockStorageApi } from "../MockStorageApi";
+import { WebStorageSessionStore } from "../../src/store/session/webstorage";
+import MockHttpBackend from "matrix-mock-request";
+import { LocalStorageCryptoStore } from "../../src/crypto/store/localStorage-crypto-store";
+import * as utils from "../test-utils";
+
+const USER_ID = "@user:test.server";
+const DEVICE_ID = "device_id";
+const ACCESS_TOKEN = "access_token";
+const ROOM_ID = "!room_id:server.test";
+
+/* global matrixcs */
+
+describe("Browserify Test", function() {
+    let client;
+    let httpBackend;
+
+    async function createTestClient() {
+        const sessionStoreBackend = new MockStorageApi();
+        const sessionStore = new WebStorageSessionStore(sessionStoreBackend);
+        const httpBackend = new MockHttpBackend();
+
+        const options = {
+            baseUrl: "http://" + USER_ID + ".test.server",
+            userId: USER_ID,
+            accessToken: ACCESS_TOKEN,
+            deviceId: DEVICE_ID,
+            sessionStore: sessionStore,
+            request: httpBackend.requestFn,
+            cryptoStore: new LocalStorageCryptoStore(sessionStoreBackend),
+        };
+
+        const client = matrixcs.createClient(options);
+
+        httpBackend.when("GET", "/pushrules").respond(200, {});
+        httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
+
+        return { client, httpBackend };
+    }
+
+    beforeEach(async () => {
+        ({ client, httpBackend } = await createTestClient());
+        await client.startClient();
+    });
+
+    afterEach(async () => {
+        client.stopClient();
+        await httpBackend.stop();
+    });
+
+    it("Sync", async function() {
+        const event = utils.mkMembership({
+            room: ROOM_ID,
+            mship: "join",
+            user: "@other_user:server.test",
+            name: "Displayname",
+        });
+
+        const syncData = {
+            next_batch: "batch1",
+            rooms: {
+                join: {},
+            },
+        };
+        syncData.rooms.join[ROOM_ID] = {
+            timeline: {
+                events: [
+                    event,
+                ],
+                limited: false,
+            },
+        };
+
+        httpBackend.when("GET", "/sync").respond(200, syncData);
+        await Promise.race([
+            Promise.all([
+                httpBackend.flushAllExpected(),
+            ]),
+            new Promise((_, reject) => {
+                client.once("sync.unexpectedError", reject);
+            }),
+        ]);
+    }, 20000); // additional timeout as this test can take quite a while
+});

spec/integ/devicelist-integ-spec.js

@@ -16,9 +16,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {TestClient} from '../TestClient';
+import { TestClient } from '../TestClient';
 import * as testUtils from '../test-utils';
-import {logger} from '../../src/logger';
+import { logger } from '../../src/logger';
 
 const ROOM_ID = "!room:id";
 
@@ -67,7 +67,6 @@ function getSyncResponse(roomMembers) {
     return syncResponse;
 }
 
-
 describe("DeviceList management:", function() {
     if (!global.Olm) {
         logger.warn('not running deviceList tests: Olm not present');
@@ -98,7 +97,7 @@ describe("DeviceList management:", function() {
     });
 
     it("Alice shouldn't do a second /query for non-e2e-capable devices", function() {
-        aliceTestClient.expectKeyQuery({device_keys: {'@alice:localhost': {}}});
+        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
         return aliceTestClient.start().then(function() {
             const syncResponse = getSyncResponse(['@bob:xyz']);
             aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
@@ -137,11 +136,10 @@ describe("DeviceList management:", function() {
         });
     });
 
-
     it("We should not get confused by out-of-order device query responses",
        () => {
-           // https://github.com/vector-im/riot-web/issues/3126
-           aliceTestClient.expectKeyQuery({device_keys: {'@alice:localhost': {}}});
+           // 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']));
@@ -160,14 +158,14 @@ describe("DeviceList management:", function() {
                );
 
                aliceTestClient.httpBackend.when('PUT', '/send/').respond(
-                   200, {event_id: '$event1'});
+                   200, { event_id: '$event1' });
 
                return Promise.all([
                    aliceTestClient.client.sendTextMessage(ROOM_ID, 'test'),
                    aliceTestClient.httpBackend.flush('/keys/query', 1).then(
                        () => aliceTestClient.httpBackend.flush('/send/', 1),
                    ),
-                   aliceTestClient.client._crypto._deviceList.saveIfDirty(),
+                   aliceTestClient.client.crypto.deviceList.saveIfDirty(),
                ]);
            }).then(() => {
                aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
@@ -199,12 +197,12 @@ describe("DeviceList management:", function() {
                    },
                    token: '3',
                }).respond(200, {
-                   device_keys: {'@chris:abc': {}},
+                   device_keys: { '@chris:abc': {} },
                });
                return aliceTestClient.httpBackend.flush('/keys/query', 1);
            }).then((flushed) => {
                expect(flushed).toEqual(0);
-               return aliceTestClient.client._crypto._deviceList.saveIfDirty();
+               return aliceTestClient.client.crypto.deviceList.saveIfDirty();
            }).then(() => {
                aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                    const bobStat = data.trackingStatus['@bob:xyz'];
@@ -228,7 +226,7 @@ describe("DeviceList management:", function() {
                    },
                    token: '2',
                }).respond(200, {
-                   device_keys: {'@bob:xyz': {}},
+                   device_keys: { '@bob:xyz': {} },
                });
                return aliceTestClient.httpBackend.flush('/keys/query', 1);
            }).then((flushed) => {
@@ -237,7 +235,7 @@ describe("DeviceList management:", function() {
                // wait for the client to stop processing the response
                return aliceTestClient.client.downloadKeys(['@bob:xyz']);
            }).then(() => {
-               return aliceTestClient.client._crypto._deviceList.saveIfDirty();
+               return aliceTestClient.client.crypto.deviceList.saveIfDirty();
            }).then(() => {
                aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                    const bobStat = data.trackingStatus['@bob:xyz'];
@@ -258,7 +256,7 @@ describe("DeviceList management:", function() {
                // wait for the client to stop processing the response
                return aliceTestClient.client.downloadKeys(['@chris:abc']);
            }).then(() => {
-               return aliceTestClient.client._crypto._deviceList.saveIfDirty();
+               return aliceTestClient.client.crypto.deviceList.saveIfDirty();
            }).then(() => {
                aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                    const bobStat = data.trackingStatus['@bob:xyz'];
@@ -271,7 +269,7 @@ describe("DeviceList management:", function() {
            });
        }).timeout(3000);
 
-    // https://github.com/vector-im/riot-web/issues/4983
+    // https://github.com/vector-im/element-web/issues/4983
     describe("Alice should know she has stale device lists", () => {
         beforeEach(async function() {
             await aliceTestClient.start();
@@ -288,7 +286,7 @@ describe("DeviceList management:", function() {
                 },
             );
             await aliceTestClient.httpBackend.flush('/keys/query', 1);
-            await aliceTestClient.client._crypto._deviceList.saveIfDirty();
+            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
 
             aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                 const bobStat = data.trackingStatus['@bob:xyz'];
@@ -323,9 +321,8 @@ describe("DeviceList management:", function() {
                 },
             );
 
-
             await aliceTestClient.flushSync();
-            await aliceTestClient.client._crypto._deviceList.saveIfDirty();
+            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
 
             aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                 const bobStat = data.trackingStatus['@bob:xyz'];
@@ -361,7 +358,7 @@ describe("DeviceList management:", function() {
             );
 
             await aliceTestClient.flushSync();
-            await aliceTestClient.client._crypto._deviceList.saveIfDirty();
+            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
 
             aliceTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                 const bobStat = data.trackingStatus['@bob:xyz'];
@@ -382,7 +379,7 @@ 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();
 
                 anotherTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
                     const bobStat = data.trackingStatus['@bob:xyz'];

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

@@ -28,11 +28,10 @@ limitations under the License.
 // load olm before the sdk if possible
 import '../olm-loader';
 
-import {logger} from '../../src/logger';
+import { logger } from '../../src/logger';
 import * as testUtils from "../test-utils";
-import * as utils from "../../src/utils";
-import {TestClient} from "../TestClient";
-import {CRYPTO_ENABLED} from "../../src/client";
+import { TestClient } from "../TestClient";
+import { CRYPTO_ENABLED } from "../../src/client";
 
 let aliTestClient;
 const roomId = "!room:localhost";
@@ -70,13 +69,13 @@ function expectAliQueryKeys() {
     aliTestClient.httpBackend.when("POST", "/keys/query")
             .respond(200, function(path, content) {
         expect(content.device_keys[bobUserId]).toEqual(
-            {},
+            [],
             "Expected Alice to key query for " + bobUserId + ", got " +
             Object.keys(content.device_keys),
         );
         const result = {};
         result[bobUserId] = bobKeys;
-        return {device_keys: result};
+        return { device_keys: result };
     });
     return aliTestClient.httpBackend.flush("/keys/query", 1);
 }
@@ -98,13 +97,13 @@ function expectBobQueryKeys() {
         "POST", "/keys/query",
     ).respond(200, function(path, content) {
         expect(content.device_keys[aliUserId]).toEqual(
-            {},
+            [],
             "Expected Bob to key query for " + aliUserId + ", got " +
             Object.keys(content.device_keys),
         );
         const result = {};
         result[aliUserId] = aliKeys;
-        return {device_keys: result};
+        return { device_keys: result };
     });
     return bobTestClient.httpBackend.flush("/keys/query", 1);
 }
@@ -133,7 +132,7 @@ function expectAliClaimKeys() {
             result[bobUserId] = {};
             result[bobUserId][bobDeviceId] = {};
             result[bobUserId][bobDeviceId][keyId] = keys[keyId];
-            return {one_time_keys: result};
+            return { one_time_keys: result };
         });
     }).then(() => {
         // it can take a while to process the key query, so give it some extra
@@ -145,7 +144,6 @@ function expectAliClaimKeys() {
     });
 }
 
-
 function aliDownloadsKeys() {
     // can't query keys before bob has uploaded them
     expect(bobTestClient.getSigningKey()).toBeTruthy();
@@ -161,7 +159,7 @@ function aliDownloadsKeys() {
     // 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();
+        return aliTestClient.client.crypto.deviceList.saveIfDirty();
     }).then(() => {
         aliTestClient.cryptoStore.getEndToEndDeviceData(null, (data) => {
             const devices = data.devices[bobUserId];
@@ -244,7 +242,7 @@ function bobSendsReplyMessage() {
 function expectAliSendMessageRequest() {
     return expectSendMessageRequest(aliTestClient.httpBackend).then(function(content) {
         aliMessages.push(content);
-        expect(utils.keys(content.ciphertext)).toEqual([bobTestClient.getDeviceKey()]);
+        expect(Object.keys(content.ciphertext)).toEqual([bobTestClient.getDeviceKey()]);
         const ciphertext = content.ciphertext[bobTestClient.getDeviceKey()];
         expect(ciphertext).toBeTruthy();
         return ciphertext;
@@ -261,7 +259,7 @@ function expectBobSendMessageRequest() {
         bobMessages.push(content);
         const aliKeyId = "curve25519:" + aliDeviceId;
         const aliDeviceCurve25519Key = aliTestClient.deviceKeys.keys[aliKeyId];
-        expect(utils.keys(content.ciphertext)).toEqual([aliDeviceCurve25519Key]);
+        expect(Object.keys(content.ciphertext)).toEqual([aliDeviceCurve25519Key]);
         const ciphertext = content.ciphertext[aliDeviceCurve25519Key];
         expect(ciphertext).toBeTruthy();
         return ciphertext;
@@ -270,7 +268,7 @@ function expectBobSendMessageRequest() {
 
 function sendMessage(client) {
     return client.sendMessage(
-        roomId, {msgtype: "m.text", body: "Hello, World"},
+        roomId, { msgtype: "m.text", body: "Hello, World" },
     );
 }
 
@@ -358,7 +356,6 @@ function recvMessage(httpBackend, client, sender, message) {
     });
 }
 
-
 /**
  * Send an initial sync response to the client (which just includes the member
  * list for our test room).
@@ -396,7 +393,6 @@ function firstSync(testClient) {
     return testClient.flushSync();
 }
 
-
 describe("MatrixClient crypto", function() {
     if (!CRYPTO_ENABLED) {
         return;
@@ -478,7 +474,7 @@ describe("MatrixClient crypto", function() {
         ).respond(200, function(path, content) {
             const result = {};
             result[bobUserId] = bobKeys;
-            return {device_keys: result};
+            return { device_keys: result };
         });
 
         return Promise.all([
@@ -520,7 +516,7 @@ describe("MatrixClient crypto", function() {
         ).respond(200, function(path, content) {
             const result = {};
             result[bobUserId] = bobKeys;
-            return {device_keys: result};
+            return { device_keys: result };
         });
 
         return Promise.all([
@@ -534,7 +530,6 @@ describe("MatrixClient crypto", function() {
         });
     });
 
-
     it("Bob starts his client and uploads device keys and one-time keys", function() {
         return Promise.resolve()
             .then(() => bobTestClient.start())
@@ -546,7 +541,7 @@ describe("MatrixClient crypto", function() {
     });
 
     it("Ali sends a message", function() {
-        aliTestClient.expectKeyQuery({device_keys: {[aliUserId]: {}}});
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
         return Promise.resolve()
             .then(() => aliTestClient.start())
             .then(() => bobTestClient.start())
@@ -556,7 +551,7 @@ describe("MatrixClient crypto", function() {
     });
 
     it("Bob receives a message", function() {
-        aliTestClient.expectKeyQuery({device_keys: {[aliUserId]: {}}});
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
         return Promise.resolve()
             .then(() => aliTestClient.start())
             .then(() => bobTestClient.start())
@@ -567,7 +562,7 @@ describe("MatrixClient crypto", function() {
     });
 
     it("Bob receives a message with a bogus sender", function() {
-        aliTestClient.expectKeyQuery({device_keys: {[aliUserId]: {}}});
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
         return Promise.resolve()
             .then(() => aliTestClient.start())
             .then(() => bobTestClient.start())
@@ -621,7 +616,7 @@ describe("MatrixClient crypto", function() {
     });
 
     it("Ali blocks Bob's device", function() {
-        aliTestClient.expectKeyQuery({device_keys: {[aliUserId]: {}}});
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
         return Promise.resolve()
             .then(() => aliTestClient.start())
             .then(() => bobTestClient.start())
@@ -641,7 +636,7 @@ describe("MatrixClient crypto", function() {
     });
 
     it("Bob receives two pre-key messages", function() {
-        aliTestClient.expectKeyQuery({device_keys: {[aliUserId]: {}}});
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
         return Promise.resolve()
             .then(() => aliTestClient.start())
             .then(() => bobTestClient.start())
@@ -654,8 +649,8 @@ describe("MatrixClient crypto", function() {
     });
 
     it("Bob replies to the message", function() {
-        aliTestClient.expectKeyQuery({device_keys: {[aliUserId]: {}}});
-        bobTestClient.expectKeyQuery({device_keys: {[bobUserId]: {}}});
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
+        bobTestClient.expectKeyQuery({ device_keys: { [bobUserId]: {} } });
         return Promise.resolve()
             .then(() => aliTestClient.start())
             .then(() => bobTestClient.start())
@@ -673,7 +668,7 @@ describe("MatrixClient crypto", function() {
     it("Ali does a key query when encryption is enabled", function() {
         // enabling encryption in the room should make alice download devices
         // for both members.
-        aliTestClient.expectKeyQuery({device_keys: {[aliUserId]: {}}});
+        aliTestClient.expectKeyQuery({ device_keys: { [aliUserId]: {} } });
         return Promise.resolve()
             .then(() => aliTestClient.start())
             .then(() => firstSync(aliTestClient))

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

@@ -1,5 +1,5 @@
 import * as utils from "../test-utils";
-import {TestClient} from "../TestClient";
+import { TestClient } from "../TestClient";
 
 describe("MatrixClient events", function() {
     let client;

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

@@ -1,7 +1,7 @@
 import * as utils from "../test-utils";
-import {EventTimeline} from "../../src/matrix";
-import {logger} from "../../src/logger";
-import {TestClient} from "../TestClient";
+import { EventTimeline } from "../../src/matrix";
+import { logger } from "../../src/logger";
+import { TestClient } from "../TestClient";
 
 const userId = "@alice:localhost";
 const userName = "Alice";
@@ -127,7 +127,7 @@ describe("getEventTimeline support", function() {
             "DEVICE",
             accessToken,
             undefined,
-            {timelineSupport: true},
+            { timelineSupport: true },
         );
         client = testClient.client;
         httpBackend = testClient.httpBackend;
@@ -141,7 +141,6 @@ describe("getEventTimeline support", function() {
         });
     });
 
-
     it("scrollback should be able to scroll back to before a gappy /sync",
       function() {
         // need a client with timelineSupport disabled to make this work
@@ -218,7 +217,7 @@ describe("MatrixClient event timelines", function() {
             "DEVICE",
             accessToken,
             undefined,
-            {timelineSupport: true},
+            { timelineSupport: true },
         );
         client = testClient.client;
         httpBackend = testClient.httpBackend;
@@ -516,7 +515,7 @@ describe("MatrixClient event timelines", function() {
                 client.getEventTimeline(timelineSet, EVENTS[0].event_id,
                 ).then(function(tl0) {
                     tl = tl0;
-                    return client.paginateEventTimeline(tl, {backwards: true});
+                    return client.paginateEventTimeline(tl, { backwards: true });
                 }).then(function(success) {
                     expect(success).toBeTruthy();
                     expect(tl.getEvents().length).toEqual(3);
@@ -532,7 +531,6 @@ describe("MatrixClient event timelines", function() {
             ]);
         });
 
-
         it("should allow you to paginate forwards", function() {
             const room = client.getRoom(roomId);
             const timelineSet = room.getTimelineSets()[0];
@@ -569,7 +567,7 @@ describe("MatrixClient event timelines", function() {
                 ).then(function(tl0) {
                     tl = tl0;
                     return client.paginateEventTimeline(
-                        tl, {backwards: false, limit: 20});
+                        tl, { backwards: false, limit: 20 });
                 }).then(function(success) {
                     expect(success).toBeTruthy();
                     expect(tl.getEvents().length).toEqual(3);
@@ -591,7 +589,7 @@ describe("MatrixClient event timelines", function() {
         const event = utils.mkMessage({
             room: roomId, user: userId, msg: "a body",
         });
-        event.unsigned = {transaction_id: TXN_ID};
+        event.unsigned = { transaction_id: TXN_ID };
 
         beforeEach(function() {
             // set up handlers for both the message send, and the
@@ -680,7 +678,6 @@ describe("MatrixClient event timelines", function() {
         });
     });
 
-
     it("should handle gappy syncs after redactions", function() {
         // https://github.com/vector-im/vector-web/issues/1389
 

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

@@ -1,7 +1,7 @@
 import * as utils from "../test-utils";
-import {CRYPTO_ENABLED} from "../../src/client";
-import {Filter, MemoryStore, Room} from "../../src/matrix";
-import {TestClient} from "../TestClient";
+import { CRYPTO_ENABLED } from "../../src/client";
+import { Filter, MemoryStore, Room } from "../../src/matrix";
+import { TestClient } from "../TestClient";
 
 describe("MatrixClient", function() {
     let client = null;
@@ -285,7 +285,6 @@ describe("MatrixClient", function() {
         });
     });
 
-
     describe("downloadKeys", function() {
         if (!CRYPTO_ENABLED) {
             return;
@@ -337,7 +336,7 @@ describe("MatrixClient", function() {
                 var b = JSON.parse(JSON.stringify(o));
                 delete(b.signatures);
                 delete(b.unsigned);
-                return client._crypto._olmDevice.sign(anotherjson.stringify(b));
+                return client.crypto.olmDevice.sign(anotherjson.stringify(b));
             };
 
             logger.log("Ed25519: " + ed25519key);
@@ -346,10 +345,10 @@ describe("MatrixClient", function() {
             */
 
             httpBackend.when("POST", "/keys/query").check(function(req) {
-                expect(req.data).toEqual({device_keys: {
-                    'boris': {},
-                    'chaz': {},
-                }});
+                expect(req.data).toEqual({ device_keys: {
+                    'boris': [],
+                    'chaz': [],
+                } });
             }).respond(200, {
                 device_keys: {
                     boris: borisKeys,
@@ -379,12 +378,12 @@ describe("MatrixClient", function() {
     });
 
     describe("deleteDevice", function() {
-        const auth = {a: 1};
+        const auth = { a: 1 };
         it("should pass through an auth dict", function() {
             httpBackend.when(
                 "DELETE", "/_matrix/client/r0/devices/my_device",
             ).check(function(req) {
-                expect(req.data).toEqual({auth: auth});
+                expect(req.data).toEqual({ auth: auth });
             }).respond(200);
 
             const prom = client.deleteDevice("my_device", auth);

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

@@ -1,8 +1,9 @@
 import * as utils from "../test-utils";
 import HttpBackend from "matrix-mock-request";
-import {MatrixClient} from "../../src/matrix";
-import {MatrixScheduler} from "../../src/scheduler";
-import {MemoryStore} from "../../src/store/memory";
+import { MatrixClient } from "../../src/matrix";
+import { MatrixScheduler } from "../../src/scheduler";
+import { MemoryStore } from "../../src/store/memory";
+import { MatrixError } from "../../src/http-api";
 
 describe("MatrixClient opts", function() {
     const baseUrl = "http://localhost.or.something";
@@ -132,10 +133,10 @@ describe("MatrixClient opts", function() {
         });
 
         it("shouldn't retry sending events", function(done) {
-            httpBackend.when("PUT", "/txn1").fail(500, {
+            httpBackend.when("PUT", "/txn1").fail(500, new MatrixError({
                 errcode: "M_SOMETHING",
                 error: "Ruh roh",
-            });
+            }));
             client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
                 expect(false).toBe(true, "sendTextMessage resolved but shouldn't");
             }, function(err) {

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

@@ -1,7 +1,7 @@
-import {EventStatus} from "../../src/matrix";
-import {MatrixScheduler} from "../../src/scheduler";
-import {Room} from "../../src/models/room";
-import {TestClient} from "../TestClient";
+import { EventStatus } from "../../src/matrix";
+import { MatrixScheduler } from "../../src/scheduler";
+import { Room } from "../../src/models/room";
+import { TestClient } from "../TestClient";
 
 describe("MatrixClient retrying", function() {
     let client = null;
@@ -19,7 +19,7 @@ describe("MatrixClient retrying", function() {
             "DEVICE",
             accessToken,
             undefined,
-            {scheduler},
+            { scheduler },
         );
         httpBackend = testClient.httpBackend;
         client = testClient.client;
@@ -90,7 +90,7 @@ describe("MatrixClient retrying", function() {
         // wait for the localecho of ev1 to be updated
         const p3 = new Promise((resolve, reject) => {
             room.on("Room.localEchoUpdated", (ev0) => {
-                if(ev0 === ev1) {
+                if (ev0 === ev1) {
                     resolve();
                 }
             });

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

@@ -1,7 +1,6 @@
 import * as utils from "../test-utils";
-import {EventStatus} from "../../src/models/event";
-import {TestClient} from "../TestClient";
-
+import { EventStatus } from "../../src/models/event";
+import { TestClient } from "../TestClient";
 
 describe("MatrixClient room timelines", function() {
     let client = null;
@@ -104,7 +103,7 @@ describe("MatrixClient room timelines", function() {
             "DEVICE",
             accessToken,
             undefined,
-            {timelineSupport: true},
+            { timelineSupport: true },
         );
         httpBackend = testClient.httpBackend;
         client = testClient.client;
@@ -166,7 +165,7 @@ describe("MatrixClient room timelines", function() {
                 body: "I am a fish", user: userId, room: roomId,
             });
             ev.event_id = eventId;
-            ev.unsigned = {transaction_id: "txn1"};
+            ev.unsigned = { transaction_id: "txn1" };
             setNextSyncData([ev]);
 
             client.on("sync", function(state) {
@@ -198,7 +197,7 @@ describe("MatrixClient room timelines", function() {
                 body: "I am a fish", user: userId, room: roomId,
             });
             ev.event_id = eventId;
-            ev.unsigned = {transaction_id: "txn1"};
+            ev.unsigned = { transaction_id: "txn1" };
             setNextSyncData([ev]);
 
             client.on("sync", function(state) {
@@ -396,8 +395,8 @@ describe("MatrixClient room timelines", function() {
     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}),
+                utils.mkMessage({ user: userId, room: roomId }),
+                utils.mkMessage({ user: userId, room: roomId }),
             ];
             setNextSyncData(eventData);
 
@@ -434,11 +433,11 @@ describe("MatrixClient room timelines", function() {
 
         it("should set the right event.sender values", function() {
             const eventData = [
-                utils.mkMessage({user: userId, room: roomId}),
+                utils.mkMessage({ user: userId, room: roomId }),
                 utils.mkMembership({
                     user: userId, room: roomId, mship: "join", name: "New Name",
                 }),
-                utils.mkMessage({user: userId, room: roomId}),
+                utils.mkMessage({ user: userId, room: roomId }),
             ];
             eventData[1].__prev_event = USER_MEMBERSHIP_EVENT;
             setNextSyncData(eventData);
@@ -546,7 +545,7 @@ describe("MatrixClient room timelines", function() {
     describe("gappy sync", function() {
         it("should copy the last known state to the new timeline", function() {
             const eventData = [
-                utils.mkMessage({user: userId, room: roomId}),
+                utils.mkMessage({ user: userId, room: roomId }),
             ];
             setNextSyncData(eventData);
             NEXT_SYNC_DATA.rooms.join[roomId].timeline.limited = true;
@@ -579,7 +578,7 @@ describe("MatrixClient room timelines", function() {
 
         it("should emit a 'Room.timelineReset' event", function() {
             const eventData = [
-                utils.mkMessage({user: userId, room: roomId}),
+                utils.mkMessage({ user: userId, room: roomId }),
             ];
             setNextSyncData(eventData);
             NEXT_SYNC_DATA.rooms.join[roomId].timeline.limited = true;

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

@@ -1,7 +1,7 @@
-import {MatrixEvent} from "../../src/models/event";
-import {EventTimeline} from "../../src/models/event-timeline";
+import { MatrixEvent } from "../../src/models/event";
+import { EventTimeline } from "../../src/models/event-timeline";
 import * as utils from "../test-utils";
-import {TestClient} from "../TestClient";
+import { TestClient } from "../TestClient";
 
 describe("MatrixClient syncing", function() {
     let client = null;
@@ -122,7 +122,6 @@ describe("MatrixClient syncing", function() {
                 resolveInvitesToProfiles: true,
             });
 
-
             return Promise.all([
                 httpBackend.flushAllExpected(),
                 awaitSyncEvent(),
@@ -677,8 +676,8 @@ describe("MatrixClient syncing", function() {
         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 }});
+                    room: { timeline: { limit: 1 },
+                            include_leave: true } });
             }).respond(200, { filter_id: "another_id" });
 
             const prom = new Promise((resolve) => {

spec/integ/megolm-integ.spec.js

@@ -16,10 +16,9 @@ limitations under the License.
 */
 
 import anotherjson from "another-json";
-import * as utils from "../../src/utils";
 import * as testUtils from "../test-utils";
-import {TestClient} from "../TestClient";
-import {logger} from "../../src/logger";
+import { TestClient } from "../TestClient";
+import { logger } from "../../src/logger";
 
 const ROOM_ID = "!room:id";
 
@@ -32,7 +31,7 @@ const ROOM_ID = "!room:id";
  */
 function createOlmSession(olmAccount, recipientTestClient) {
     return recipientTestClient.awaitOneTimeKeyUpload().then((keys) => {
-        const otkId = utils.keys(keys)[0];
+        const otkId = Object.keys(keys)[0];
         const otk = keys[otkId];
 
         const session = new global.Olm.Session();
@@ -197,7 +196,6 @@ function getSyncResponse(roomMembers) {
     return syncResponse;
 }
 
-
 describe("megolm", function() {
     if (!global.Olm) {
         logger.warn('not running megolm tests: Olm not present');
@@ -257,7 +255,7 @@ describe("megolm", function() {
         const testOneTimeKeys = JSON.parse(testOlmAccount.one_time_keys());
         testOlmAccount.mark_keys_as_published();
 
-        const keyId = utils.keys(testOneTimeKeys.curve25519)[0];
+        const keyId = Object.keys(testOneTimeKeys.curve25519)[0];
         const oneTimeKey = testOneTimeKeys.curve25519[keyId];
         const keyResult = {
             'key': oneTimeKey,
@@ -269,7 +267,7 @@ describe("megolm", function() {
             'ed25519:DEVICE_ID': sig,
         };
 
-        const claimResponse = {one_time_keys: {}};
+        const claimResponse = { one_time_keys: {} };
         claimResponse.one_time_keys[userId] = {
             'DEVICE_ID': {},
         };
@@ -346,7 +344,7 @@ describe("megolm", function() {
     });
 
     it("Alice receives a megolm message before the session keys", function() {
-        // https://github.com/vector-im/riot-web/issues/2273
+        // https://github.com/vector-im/element-web/issues/2273
         let roomKeyEncrypted;
 
         return aliceTestClient.start().then(() => {
@@ -484,8 +482,9 @@ describe("megolm", function() {
             return aliceTestClient.flushSync().then(() => {
                 return aliceTestClient.flushSync();
             });
-        }).then(function() {
+        }).then(async function() {
             const room = aliceTestClient.client.getRoom(ROOM_ID);
+            await room.decryptCriticalEvents();
             const event = room.getLiveTimeline().getEvents()[0];
             expect(event.getContent().body).toEqual('42');
         });
@@ -494,7 +493,7 @@ describe("megolm", function() {
     it('Alice sends a megolm message', function() {
         let p2pSession;
 
-        aliceTestClient.expectKeyQuery({device_keys: {'@alice:localhost': {}}});
+        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
         return aliceTestClient.start().then(() => {
             // establish an olm session with alice
             return createOlmSession(testOlmAccount, aliceTestClient);
@@ -577,7 +576,7 @@ describe("megolm", function() {
     });
 
     it("We shouldn't attempt to send to blocked devices", function() {
-        aliceTestClient.expectKeyQuery({device_keys: {'@alice:localhost': {}}});
+        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
         return aliceTestClient.start().then(() => {
             // establish an olm session with alice
             return createOlmSession(testOlmAccount, aliceTestClient);
@@ -634,7 +633,7 @@ describe("megolm", function() {
         let p2pSession;
         let megolmSessionId;
 
-        aliceTestClient.expectKeyQuery({device_keys: {'@alice:localhost': {}}});
+        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
         return aliceTestClient.start().then(() => {
             // establish an olm session with alice
             return createOlmSession(testOlmAccount, aliceTestClient);
@@ -726,7 +725,7 @@ describe("megolm", function() {
         });
     });
 
-    // https://github.com/vector-im/riot-web/issues/2676
+    // https://github.com/vector-im/element-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.
@@ -841,13 +840,12 @@ describe("megolm", function() {
         });
     });
 
-
     it('Alice should wait for device list to complete when sending a megolm message',
     function() {
         let downloadPromise;
         let sendPromise;
 
-        aliceTestClient.expectKeyQuery({device_keys: {'@alice:localhost': {}}});
+        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
         return aliceTestClient.start().then(() => {
             // establish an olm session with alice
             return createOlmSession(testOlmAccount, aliceTestClient);
@@ -887,11 +885,10 @@ describe("megolm", function() {
         });
     });
 
-
     it("Alice exports megolm keys and imports them to a new device", function() {
         let messageEncrypted;
 
-        aliceTestClient.expectKeyQuery({device_keys: {'@alice:localhost': {}}});
+        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
         return aliceTestClient.start().then(() => {
             // establish an olm session with alice
             return createOlmSession(testOlmAccount, aliceTestClient);
@@ -933,8 +930,9 @@ describe("megolm", function() {
 
             aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
             return aliceTestClient.flushSync();
-        }).then(function() {
+        }).then(async function() {
             const room = aliceTestClient.client.getRoom(ROOM_ID);
+            await room.decryptCriticalEvents();
             const event = room.getLiveTimeline().getEvents()[0];
             expect(event.getContent().body).toEqual('42');
 
@@ -971,4 +969,124 @@ describe("megolm", function() {
             expect(event.getContent().body).toEqual('42');
         });
     });
+
+    it("Alice receives an untrusted megolm key, only to receive the trusted one shortly after", function() {
+        const testClient = new TestClient(
+            "@alice:localhost", "device2", "access_token2",
+        );
+        const groupSession = new Olm.OutboundGroupSession();
+        groupSession.create();
+        const inboundGroupSession = new Olm.InboundGroupSession();
+        inboundGroupSession.create(groupSession.session_key());
+        const rawEvent = encryptMegolmEvent({
+            senderKey: testSenderKey,
+            groupSession: groupSession,
+            room_id: ROOM_ID,
+        });
+        return testClient.client.initCrypto().then(() => {
+            const keys = [{
+                room_id: ROOM_ID,
+                algorithm: 'm.megolm.v1.aes-sha2',
+                session_id: groupSession.session_id(),
+                session_key: inboundGroupSession.export_session(0),
+                sender_key: testSenderKey,
+            }];
+            return testClient.client.importRoomKeys(keys, { untrusted: true });
+        }).then(() => {
+            const event = testUtils.mkEvent({
+                event: true,
+                ...rawEvent,
+                room: ROOM_ID,
+            });
+            return event.attemptDecryption(testClient.client.crypto, true).then(() => {
+                expect(event.isKeySourceUntrusted()).toBeTruthy();
+            });
+        }).then(() => {
+            const event = testUtils.mkEvent({
+                type: 'm.room_key',
+                content: {
+                    room_id: ROOM_ID,
+                    algorithm: 'm.megolm.v1.aes-sha2',
+                    session_id: groupSession.session_id(),
+                    session_key: groupSession.session_key(),
+                },
+                event: true,
+            });
+            event.senderCurve25519Key = testSenderKey;
+            return testClient.client.crypto.onRoomKeyEvent(event);
+        }).then(() => {
+            const event = testUtils.mkEvent({
+                event: true,
+                ...rawEvent,
+                room: ROOM_ID,
+            });
+            return event.attemptDecryption(testClient.client.crypto, true).then(() => {
+                expect(event.isKeySourceUntrusted()).toBeFalsy();
+            });
+        });
+    });
+
+    it("Alice can decrypt a message with falsey content", 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,
+            });
+
+            const plaintext = {
+                type: "m.room.message",
+                content: undefined,
+                room_id: ROOM_ID,
+            };
+
+            const messageEncrypted = {
+                event_id: 'test_megolm_event',
+                content: {
+                    algorithm: "m.megolm.v1.aes-sha2",
+                    ciphertext: groupSession.encrypt(JSON.stringify(plaintext)),
+                    device_id: "testDevice",
+                    sender_key: testSenderKey,
+                    session_id: groupSession.session_id(),
+                },
+                type: "m.room.encrypted",
+            };
+
+            // 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.getRoomId()).toEqual(ROOM_ID);
+            expect(event.getContent()).toEqual({});
+            expect(event.getClearContent()).toBeUndefined();
+        });
+    });
 });

spec/olm-loader.js

@@ -15,12 +15,21 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {logger} from '../src/logger';
+import { logger } from '../src/logger';
+import * as utils from "../src/utils";
 
 // try to load the olm library.
 try {
-    global.Olm = require('olm');
+    global.Olm = require('@matrix-org/olm');
     logger.log('loaded libolm');
 } catch (e) {
     logger.warn("unable to run crypto tests: libolm not available");
 }
+
+// also try to set node crypto
+try {
+    const crypto = require('crypto');
+    utils.setCrypto(crypto);
+} catch (err) {
+    logger.log('nodejs was compiled without crypto support: some tests will fail');
+}

spec/test-utils.js

@@ -1,8 +1,8 @@
 // load olm before the sdk if possible
 import './olm-loader';
 
-import {logger} from '../src/logger';
-import {MatrixEvent} from "../src/models/event";
+import { logger } from '../src/logger';
+import { MatrixEvent } from "../src/models/event";
 
 /**
  * Return a promise that is resolved when the client next emits a
@@ -51,7 +51,7 @@ export function mock(constr, name) {
     result.toString = function() {
         return "mock" + (name ? " of " + name : "");
     };
-    for (const key in constr.prototype) { // eslint-disable-line guard-for-in
+    for (const key of Object.getOwnPropertyNames(constr.prototype)) { // eslint-disable-line guard-for-in
         try {
             if (constr.prototype[key] instanceof Function) {
                 result[key] = jest.fn();
@@ -91,7 +91,7 @@ export function mkEvent(opts) {
         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) {
+         "com.example.state"].includes(opts.type)) {
         event.state_key = "";
     }
     return opts.event ? new MatrixEvent(event) : event;
@@ -177,7 +177,6 @@ export function mkMessage(opts) {
     return mkEvent(opts);
 }
 
-
 /**
  * A mock implementation of webstorage
  *
@@ -204,7 +203,6 @@ MockStorageApi.prototype = {
     },
 };
 
-
 /**
  * If an event is being decrypted, wait for it to finish being decrypted.
  *
@@ -212,21 +210,23 @@ MockStorageApi.prototype = {
  * @returns {Promise} promise which resolves (to `event`) when the event has been decrypted
  */
 export function awaitDecryption(event) {
-    if (!event.isBeingDecrypted()) {
-        return Promise.resolve(event);
-    }
+    // 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`);
 
-    logger.log(`${Date.now()} event ${event.getId()} is being decrypted; waiting`);
-
-    return new Promise((resolve, reject) => {
-        event.once('Event.decrypted', (ev) => {
-            logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
-            resolve(ev);
+        return new Promise((resolve, reject) => {
+            event.once('Event.decrypted', (ev) => {
+                logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
+                resolve(ev);
+            });
         });
-    });
+    }
 }
 
-
 export function HttpResponse(
     httpLookups, acceptKeepalives, ignoreUnhandledSync,
 ) {
@@ -357,12 +357,12 @@ export function setHttpResponses(
     );
 
     const httpReq = httpResponseObj.request.bind(httpResponseObj);
-    client._http = [
+    client.http = [
         "authedRequest", "authedRequestWithPrefix", "getContentUri",
         "request", "requestWithPrefix", "uploadContent",
     ].reduce((r, k) => {r[k] = jest.fn(); return r;}, {});
-    client._http.authedRequest.mockImplementation(httpReq);
-    client._http.authedRequestWithPrefix.mockImplementation(httpReq);
-    client._http.requestWithPrefix.mockImplementation(httpReq);
-    client._http.request.mockImplementation(httpReq);
+    client.http.authedRequest.mockImplementation(httpReq);
+    client.http.authedRequestWithPrefix.mockImplementation(httpReq);
+    client.http.requestWithPrefix.mockImplementation(httpReq);
+    client.http.request.mockImplementation(httpReq);
 }

spec/unit/NamespacedValue.spec.ts

@@ -0,0 +1,78 @@
+/*
+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);
+    });
+
+    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();
+    });
+
+    it("should have a falsey unstable if needed", () => {
+        const ns = new NamespacedValue("stable", null);
+        expect(ns.name).toBe(ns.stable);
+        expect(ns.altName).toBeFalsy();
+    });
+
+    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(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);
+    });
+
+    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();
+    });
+
+    it("should not permit falsey unstable values", () => {
+        try {
+            new UnstableValue("stable", null);
+            // noinspection ExceptionCaughtLocallyJS
+            throw new Error("Failed to fail");
+        } catch (e) {
+            expect(e.message).toBe("Unstable value must be supplied");
+        }
+    });
+});

spec/unit/ReEmitter.spec.ts

@@ -0,0 +1,72 @@
+/*
+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 { 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();
+    });
+});

spec/unit/autodiscovery.spec.js

@@ -17,7 +17,7 @@ limitations under the License.
 
 import MockHttpBackend from "matrix-mock-request";
 import * as sdk from "../../src";
-import {AutoDiscovery} from "../../src/autodiscovery";
+import { AutoDiscovery } from "../../src/autodiscovery";
 
 describe("AutoDiscovery", function() {
     let httpBackend = null;

spec/unit/content-repo.spec.js

@@ -1,4 +1,4 @@
-import {getHttpUriForMxc, getIdenticonUri} from "../../src/content-repo";
+import { getHttpUriForMxc } from "../../src/content-repo";
 
 describe("ContentRepo", function() {
     const baseUrl = "https://my.home.server";
@@ -56,31 +56,4 @@ describe("ContentRepo", function() {
             );
         });
     });
-
-    describe("getIdenticonUri", function() {
-        it("should do nothing for null input", function() {
-            expect(getIdenticonUri(null)).toEqual(null);
-        });
-
-        it("should set w/h by default to 96", function() {
-            expect(getIdenticonUri(baseUrl, "foobar")).toEqual(
-                baseUrl + "/_matrix/media/unstable/identicon/foobar" +
-                "?width=96&height=96",
-            );
-        });
-
-        it("should be able to set custom w/h", function() {
-            expect(getIdenticonUri(baseUrl, "foobar", 32, 64)).toEqual(
-                baseUrl + "/_matrix/media/unstable/identicon/foobar" +
-                "?width=32&height=64",
-            );
-        });
-
-        it("should URL encode the identicon string", function() {
-            expect(getIdenticonUri(baseUrl, "foo#bar", 32, 64)).toEqual(
-                baseUrl + "/_matrix/media/unstable/identicon/foo%23bar" +
-                "?width=32&height=64",
-            );
-        });
-    });
 });

spec/unit/crypto.spec.js

@@ -1,15 +1,16 @@
 import '../olm-loader';
-import {Crypto} from "../../src/crypto";
-import {WebStorageSessionStore} from "../../src/store/session/webstorage";
-import {MemoryCryptoStore} from "../../src/crypto/store/memory-crypto-store";
-import {MockStorageApi} from "../MockStorageApi";
-import {TestClient} from "../TestClient";
-import {MatrixEvent} from "../../src/models/event";
-import {Room} from "../../src/models/room";
+import { Crypto } from "../../src/crypto";
+import { WebStorageSessionStore } from "../../src/store/session/webstorage";
+import { MemoryCryptoStore } from "../../src/crypto/store/memory-crypto-store";
+import { MockStorageApi } from "../MockStorageApi";
+import { TestClient } from "../TestClient";
+import { MatrixEvent } from "../../src/models/event";
+import { Room } from "../../src/models/room";
 import * as olmlib from "../../src/crypto/olmlib";
-import {sleep} from "../../src/utils";
-import {EventEmitter} from "events";
-import {CRYPTO_ENABLED} from "../../src/client";
+import { sleep } from "../../src/utils";
+import { EventEmitter } from "events";
+import { CRYPTO_ENABLED } from "../../src/client";
+import { DeviceInfo } from "../../src/crypto/deviceinfo";
 
 const Olm = global.Olm;
 
@@ -26,6 +27,66 @@ describe("Crypto", function() {
         expect(Crypto.getOlmVersion()[0]).toEqual(3);
     });
 
+    describe("encrypted events", function() {
+        it("provides encryption information", async function() {
+            const client = (new TestClient(
+                "@alice:example.com", "deviceid",
+            )).client;
+            await client.initCrypto();
+
+            // unencrypted event
+            const event = {
+                getId: () => "$event_id",
+                getSenderKey: () => null,
+                getWireContent: () => {return {};},
+            };
+
+            let encryptionInfo = client.getEventEncryptionInfo(event);
+            expect(encryptionInfo.encrypted).toBeFalsy();
+
+            // unknown sender (e.g. deleted device), forwarded megolm key (untrusted)
+            event.getSenderKey = () => 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI';
+            event.getWireContent = () => {return { algorithm: olmlib.MEGOLM_ALGORITHM };};
+            event.getForwardingCurve25519KeyChain = () => ["not empty"];
+            event.isKeySourceUntrusted = () => false;
+            event.getClaimedEd25519Key =
+                () => 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
+
+            encryptionInfo = client.getEventEncryptionInfo(event);
+            expect(encryptionInfo.encrypted).toBeTruthy();
+            expect(encryptionInfo.authenticated).toBeFalsy();
+            expect(encryptionInfo.sender).toBeFalsy();
+
+            // known sender, megolm key from backup
+            event.getForwardingCurve25519KeyChain = () => [];
+            event.isKeySourceUntrusted = () => true;
+            const device = new DeviceInfo("FLIBBLE");
+            device.keys["curve25519:FLIBBLE"] =
+                'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI';
+            device.keys["ed25519:FLIBBLE"] =
+                'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
+            client.crypto.deviceList.getDeviceByIdentityKey = () => device;
+
+            encryptionInfo = client.getEventEncryptionInfo(event);
+            expect(encryptionInfo.encrypted).toBeTruthy();
+            expect(encryptionInfo.authenticated).toBeFalsy();
+            expect(encryptionInfo.sender).toBeTruthy();
+            expect(encryptionInfo.mismatchedSender).toBeFalsy();
+
+            // known sender, trusted megolm key, but bad ed25519key
+            event.isKeySourceUntrusted = () => false;
+            device.keys["ed25519:FLIBBLE"] =
+                'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB';
+
+            encryptionInfo = client.getEventEncryptionInfo(event);
+            expect(encryptionInfo.encrypted).toBeTruthy();
+            expect(encryptionInfo.authenticated).toBeTruthy();
+            expect(encryptionInfo.sender).toBeTruthy();
+            expect(encryptionInfo.mismatchedSender).toBeTruthy();
+
+            client.stopClient();
+        });
+    });
 
     describe('Session management', function() {
         const otkResponse = {
@@ -152,7 +213,7 @@ describe("Crypto", function() {
 
                 async function keyshareEventForEvent(event, index) {
                     const eventContent = event.getWireContent();
-                    const key = await aliceClient._crypto._olmDevice
+                    const key = await aliceClient.crypto.olmDevice
                         .getInboundGroupSessionKey(
                             roomId, eventContent.sender_key, eventContent.session_id,
                             index,
@@ -173,7 +234,7 @@ describe("Crypto", function() {
                         },
                     });
                     // make onRoomKeyEvent think this was an encrypted event
-                    ksEvent._senderCurve25519Key = "akey";
+                    ksEvent.senderCurve25519Key = "akey";
                     return ksEvent;
                 }
 
@@ -212,19 +273,19 @@ describe("Crypto", function() {
                 await Promise.all(events.map(async (event) => {
                     // alice encrypts each event, and then bob tries to decrypt
                     // them without any keys, so that they'll be in pending
-                    await aliceClient._crypto.encryptEvent(event, aliceRoom);
-                    event._clearEvent = {};
-                    event._senderCurve25519Key = null;
-                    event._claimedEd25519Key = null;
+                    await aliceClient.crypto.encryptEvent(event, aliceRoom);
+                    event.clearEvent = undefined;
+                    event.senderCurve25519Key = null;
+                    event.claimedEd25519Key = null;
                     try {
-                        await bobClient._crypto.decryptEvent(event);
+                        await bobClient.crypto.decryptEvent(event);
                     } catch (e) {
                         // we expect this to fail because we don't have the
                         // decryption keys yet
                     }
                 }));
 
-                const bobDecryptor = bobClient._crypto._getRoomDecryptor(
+                const bobDecryptor = bobClient.crypto.getRoomDecryptor(
                     roomId, olmlib.MEGOLM_ALGORITHM,
                 );
 
@@ -241,7 +302,7 @@ describe("Crypto", function() {
                 expect(events[0].getContent().msgtype).toBe("m.bad.encrypted");
                 expect(events[1].getContent().msgtype).not.toBe("m.bad.encrypted");
 
-                const cryptoStore = bobClient._cryptoStore;
+                const cryptoStore = bobClient.cryptoStore;
                 const eventContent = events[0].getWireContent();
                 const senderKey = eventContent.sender_key;
                 const sessionId = eventContent.session_id;
@@ -283,7 +344,7 @@ describe("Crypto", function() {
                 },
             });
             await aliceClient.cancelAndResendEventRoomKeyRequest(event);
-            const cryptoStore = aliceClient._cryptoStore;
+            const cryptoStore = aliceClient.cryptoStore;
             const roomKeyRequestBody = {
                 algorithm: olmlib.MEGOLM_ALGORITHM,
                 room_id: "!someroom",
@@ -313,6 +374,10 @@ describe("Crypto", function() {
             // make a room key request, and record the transaction ID for the
             // sendToDevice call
             await aliceClient.cancelAndResendEventRoomKeyRequest(event);
+            // key requests get queued until the sync has finished, but we don't
+            // let the client set up enough for that to happen, so gut-wrench a bit
+            // to force it to send now.
+            aliceClient.crypto.outgoingRoomKeyRequestManager.sendQueuedRequests();
             jest.runAllTimers();
             await Promise.resolve();
             expect(aliceClient.sendToDevice).toBeCalledTimes(1);

spec/unit/crypto/CrossSigningInfo.spec.js

@@ -22,9 +22,11 @@ import {
 import {
     IndexedDBCryptoStore,
 } from '../../../src/crypto/store/indexeddb-crypto-store';
-import {MemoryCryptoStore} from '../../../src/crypto/store/memory-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";
 
@@ -37,7 +39,7 @@ const testKey = new Uint8Array([
 ]);
 
 const types = [
-    { type: "master", shouldCache: false },
+    { type: "master", shouldCache: true },
     { type: "self_signing", shouldCache: true },
     { type: "user_signing", shouldCache: true },
     { type: "invalid", shouldCache: false },
@@ -50,7 +52,7 @@ const masterKeyPub = "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk";
 
 describe("CrossSigningInfo.getCrossSigningKey", function() {
     if (!global.Olm) {
-        console.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn('Not running megolm backup unit tests: libolm not present');
         return;
     }
 
@@ -64,7 +66,7 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
     });
 
     it.each(types)("should throw if the callback returns falsey",
-                   async ({type, shouldCache}) => {
+                   async ({ type, shouldCache }) => {
         const info = new CrossSigningInfo(userId, {
             getCrossSigningKey: () => false,
         });
@@ -82,9 +84,16 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
         const info = new CrossSigningInfo(userId, {
             getCrossSigningKey: () => testKey,
         });
-        const [pubKey, ab] = await info.getCrossSigningKey("master", masterKeyPub);
+        const [pubKey, pkSigning] = await info.getCrossSigningKey("master", masterKeyPub);
         expect(pubKey).toEqual(masterKeyPub);
-        expect(ab).toEqual({a: 106712, b: 106712});
+        // 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)" +
@@ -233,8 +242,9 @@ describe.each([
 
     it("should cache data to the store and retrieve it", async () => {
         await store.startup();
+        const olmDevice = new OlmDevice(store);
         const { getCrossSigningKeyCache, storeCrossSigningKeyCache } =
-          createCryptoStoreCacheCallbacks(store);
+              createCryptoStoreCacheCallbacks(store, olmDevice);
         await storeCrossSigningKeyCache("self_signing", testKey);
 
         // If we've not saved anything, don't expect anything
@@ -243,6 +253,6 @@ describe.each([
         expect(nokey).toBeNull();
 
         const key = await getCrossSigningKeyCache("self_signing", "");
-        expect(key).toEqual(testKey);
+        expect(new Uint8Array(key)).toEqual(testKey);
     });
 });

spec/unit/crypto/DeviceList.spec.js

@@ -16,10 +16,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {logger} from "../../../src/logger";
+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 { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
+import { DeviceList } from "../../../src/crypto/DeviceList";
 
 const signedDeviceList = {
     "failures": {},
@@ -51,6 +51,36 @@ const signedDeviceList = {
     },
 };
 
+const signedDeviceList2 = {
+    "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": {},
+            },
+        },
+    },
+};
+
 describe('DeviceList', function() {
     let downloadSpy;
     let cryptoStore;
@@ -69,14 +99,16 @@ describe('DeviceList', function() {
         }
     });
 
-    function createTestDeviceList() {
+    function createTestDeviceList(keyDownloadChunkSize = 250) {
         const baseApis = {
             downloadKeysForUsers: downloadSpy,
+            getUserId: () => '@test1:sw1v.org',
+            deviceId: 'HGKAWHRVJQ',
         };
         const mockOlm = {
             verifySignature: function(key, message, signature) {},
         };
-        const dl = new DeviceList(baseApis, cryptoStore, mockOlm);
+        const dl = new DeviceList(baseApis, cryptoStore, mockOlm, keyDownloadChunkSize);
         deviceLists.push(dl);
         return dl;
     }
@@ -148,4 +180,30 @@ describe('DeviceList', function() {
             expect(Object.keys(storedKeys)).toEqual(['HGKAWHRVJQ']);
         });
     });
+
+    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();
+        downloadSpy.mockReturnValueOnce(queryDefer1.promise);
+        const queryDefer2 = utils.defer();
+        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']);
+        });
+    });
 });

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

@@ -1,14 +1,14 @@
 import '../../../olm-loader';
 import * as algorithms from "../../../../src/crypto/algorithms";
-import {MemoryCryptoStore} from "../../../../src/crypto/store/memory-crypto-store";
-import {MockStorageApi} from "../../../MockStorageApi";
+import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
+import { MockStorageApi } from "../../../MockStorageApi";
 import * as testUtils from "../../../test-utils";
-import {OlmDevice} from "../../../../src/crypto/OlmDevice";
-import {Crypto} from "../../../../src/crypto";
-import {logger} from "../../../../src/logger";
-import {MatrixEvent} from "../../../../src/models/event";
-import {TestClient} from "../../../TestClient";
-import {Room} from "../../../../src/models/room";
+import { OlmDevice } from "../../../../src/crypto/OlmDevice";
+import { Crypto } from "../../../../src/crypto";
+import { logger } from "../../../../src/logger";
+import { MatrixEvent } from "../../../../src/models/event";
+import { TestClient } from "../../../TestClient";
+import { Room } from "../../../../src/models/room";
 import * as olmlib from "../../../../src/crypto/olmlib";
 
 const MegolmDecryption = algorithms.DECRYPTION_CLASSES['m.megolm.v1.aes-sha2'];
@@ -50,7 +50,6 @@ describe("MegolmDecryption", function() {
             roomId: ROOM_ID,
         });
 
-
         // we stub out the olm encryption bits
         mockOlmLib = {};
         mockOlmLib.ensureOlmSessionsForDevices = jest.fn();
@@ -136,9 +135,9 @@ describe("MegolmDecryption", function() {
                 mockCrypto.getStoredDevice.mockReturnValue(deviceInfo);
 
                 mockOlmLib.ensureOlmSessionsForDevices.mockResolvedValue({
-                    '@alice:foo': {'alidevice': {
+                    '@alice:foo': { 'alidevice': {
                         sessionId: 'alisession',
-                    }},
+                    } },
                 });
 
                 const awaitEncryptForDevice = new Promise((res, rej) => {
@@ -257,94 +256,145 @@ describe("MegolmDecryption", function() {
             });
         });
 
-        it("re-uses sessions for sequential messages", async function() {
-            const mockStorage = new MockStorageApi();
-            const cryptoStore = new MemoryCryptoStore(mockStorage);
+        describe("session reuse and key reshares", () => {
+            let megolmEncryption;
+            let aliceDeviceInfo;
+            let mockRoom;
+            let olmDevice;
 
-            const olmDevice = new OlmDevice(cryptoStore);
-            olmDevice.verifySignature = jest.fn();
-            await olmDevice.init();
+            beforeEach(async () => {
+                mockCrypto.backupManager = {
+                    backupGroupSession: () => {},
+                };
+                const mockStorage = new MockStorageApi();
+                const cryptoStore = new MemoryCryptoStore(mockStorage);
 
-            mockBaseApis.claimOneTimeKeys = jest.fn().mockReturnValue(Promise.resolve({
-                one_time_keys: {
-                    '@alice:home.server': {
-                        aliceDevice: {
-                            'signed_curve25519:flooble': {
-                                key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
-                                signatures: {
-                                    '@alice:home.server': {
-                                        'ed25519:aliceDevice': 'totally valid',
+                olmDevice = new OlmDevice(cryptoStore);
+                olmDevice.verifySignature = jest.fn();
+                await olmDevice.init();
+
+                mockBaseApis.claimOneTimeKeys = jest.fn().mockReturnValue(Promise.resolve({
+                    one_time_keys: {
+                        '@alice:home.server': {
+                            aliceDevice: {
+                                'signed_curve25519:flooble': {
+                                    key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
+                                    signatures: {
+                                        '@alice:home.server': {
+                                            'ed25519:aliceDevice': 'totally valid',
+                                        },
                                     },
                                 },
                             },
                         },
                     },
-                },
-            }));
-            mockBaseApis.sendToDevice = jest.fn().mockResolvedValue(undefined);
+                }));
+                mockBaseApis.sendToDevice = jest.fn().mockResolvedValue(undefined);
 
-            mockCrypto.downloadKeys.mockReturnValue(Promise.resolve({
-                '@alice:home.server': {
-                    aliceDevice: {
-                        deviceId: 'aliceDevice',
-                        isBlocked: jest.fn().mockReturnValue(false),
-                        isUnverified: jest.fn().mockReturnValue(false),
-                        getIdentityKey: jest.fn().mockReturnValue(
-                            'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
-                        ),
-                        getFingerprint: jest.fn().mockReturnValue(''),
+                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,
+                mockCrypto.checkDeviceTrust.mockReturnValue({
+                    isVerified: () => false,
+                });
+
+                megolmEncryption = new MegolmEncryption({
+                    userId: '@user:id',
+                    crypto: mockCrypto,
+                    olmDevice: olmDevice,
+                    baseApis: mockBaseApis,
+                    roomId: ROOM_ID,
+                    config: {
+                        rotation_period_ms: 9999999999999,
+                    },
+                });
+                mockRoom = {
+                    getEncryptionTargetMembers: jest.fn().mockReturnValue(
+                        [{ userId: "@alice:home.server" }],
+                    ),
+                    getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
+                };
             });
 
-            const megolmEncryption = new MegolmEncryption({
-                userId: '@user:id',
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: mockBaseApis,
-                roomId: ROOM_ID,
-                config: {
-                    rotation_period_ms: 9999999999999,
-                },
-            });
-            const mockRoom = {
-                getEncryptionTargetMembers: jest.fn().mockReturnValue(
-                    [{userId: "@alice:home.server"}],
-                ),
-                getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
-            };
-            const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                body: "Some text",
-            });
-            expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
+            it("re-uses sessions for sequential messages", async function() {
+                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some text",
+                });
+                expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
 
-            // this should have claimed a key for alice as it's starting a new session
-            expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-            );
-            expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
-                ['@alice:home.server'], false,
-            );
-            expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
-            expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-            );
+                // this should have claimed a key for alice as it's starting a new session
+                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
+                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
+                );
+                expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
+                    ['@alice:home.server'], false,
+                );
+                expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
+                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
+                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
+                );
 
-            mockBaseApis.claimOneTimeKeys.mockReset();
+                mockBaseApis.claimOneTimeKeys.mockReset();
 
-            const ct2 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                body: "Some more text",
+                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);
             });
 
-            // this should *not* have claimed a key as it should be using the same session
-            expect(mockBaseApis.claimOneTimeKeys).not.toHaveBeenCalled();
+            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",
+                });
 
-            // likewise they should show the same session ID
-            expect(ct2.session_id).toEqual(ct1.session_id);
+                mockBaseApis.sendToDevice.mockClear();
+                await megolmEncryption.reshareKeyWithDevice(
+                    olmDevice.deviceCurve25519Key,
+                    ct1.session_id,
+                    '@alice:home.server',
+                    aliceDeviceInfo,
+                );
+
+                expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
+            });
+
+            it("does not re-share keys to devices whose keys have changed", async function() {
+                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some text",
+                });
+
+                aliceDeviceInfo.getIdentityKey = jest.fn().mockReturnValue(
+                    'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWI',
+                );
+
+                mockBaseApis.sendToDevice.mockClear();
+                await megolmEncryption.reshareKeyWithDevice(
+                    olmDevice.deviceCurve25519Key,
+                    ct1.session_id,
+                    '@alice:home.server',
+                    aliceDeviceInfo,
+                );
+
+                expect(mockBaseApis.sendToDevice).not.toHaveBeenCalled();
+            });
         });
     });
 
@@ -363,9 +413,9 @@ describe("MegolmDecryption", function() {
             bobClient1.initCrypto(),
             bobClient2.initCrypto(),
         ]);
-        const aliceDevice = aliceClient._crypto._olmDevice;
-        const bobDevice1 = bobClient1._crypto._olmDevice;
-        const bobDevice2 = bobClient2._crypto._olmDevice;
+        const aliceDevice = aliceClient.crypto.olmDevice;
+        const bobDevice1 = bobClient1.crypto.olmDevice;
+        const bobDevice2 = bobClient2.crypto.olmDevice;
 
         const encryptionCfg = {
             "algorithm": "m.megolm.v1.aes-sha2",
@@ -373,7 +423,7 @@ describe("MegolmDecryption", function() {
         const roomId = "!someroom";
         const room = new Room(roomId, aliceClient, "@alice:example.com", {});
         room.getEncryptionTargetMembers = async function() {
-            return [{userId: "@bob:example.com"}];
+            return [{ userId: "@bob:example.com" }];
         };
         room.setBlacklistUnverifiedDevices(true);
         aliceClient.store.storeRoom(room);
@@ -402,11 +452,11 @@ describe("MegolmDecryption", function() {
             },
         };
 
-        aliceClient._crypto._deviceList.storeDevicesForUser(
+        aliceClient.crypto.deviceList.storeDevicesForUser(
             "@bob:example.com", BOB_DEVICES,
         );
-        aliceClient._crypto._deviceList.downloadKeys = async function(userIds) {
-            return this._getDevicesFromStore(userIds);
+        aliceClient.crypto.deviceList.downloadKeys = async function(userIds) {
+            return this.getDevicesFromStore(userIds);
         };
 
         let run = false;
@@ -446,7 +496,7 @@ describe("MegolmDecryption", function() {
                 body: "secret",
             },
         });
-        await aliceClient._crypto.encryptEvent(event, room);
+        await aliceClient.crypto.encryptEvent(event, room);
 
         expect(run).toBe(true);
 
@@ -466,8 +516,8 @@ describe("MegolmDecryption", function() {
             aliceClient.initCrypto(),
             bobClient.initCrypto(),
         ]);
-        const aliceDevice = aliceClient._crypto._olmDevice;
-        const bobDevice = bobClient._crypto._olmDevice;
+        const aliceDevice = aliceClient.crypto.olmDevice;
+        const bobDevice = bobClient.crypto.olmDevice;
 
         const encryptionCfg = {
             "algorithm": "m.megolm.v1.aes-sha2",
@@ -506,11 +556,11 @@ describe("MegolmDecryption", function() {
             },
         };
 
-        aliceClient._crypto._deviceList.storeDevicesForUser(
+        aliceClient.crypto.deviceList.storeDevicesForUser(
             "@bob:example.com", BOB_DEVICES,
         );
-        aliceClient._crypto._deviceList.downloadKeys = async function(userIds) {
-            return this._getDevicesFromStore(userIds);
+        aliceClient.crypto.deviceList.downloadKeys = async function(userIds) {
+            return this.getDevicesFromStore(userIds);
         };
 
         aliceClient.claimOneTimeKeys = async () => {
@@ -544,7 +594,7 @@ describe("MegolmDecryption", function() {
             event_id: "$event",
             content: {},
         });
-        await aliceClient._crypto.encryptEvent(event, aliceRoom);
+        await aliceClient.crypto.encryptEvent(event, aliceRoom);
         await sendPromise;
     });
 
@@ -559,11 +609,11 @@ describe("MegolmDecryption", function() {
             aliceClient.initCrypto(),
             bobClient.initCrypto(),
         ]);
-        const bobDevice = bobClient._crypto._olmDevice;
+        const bobDevice = bobClient.crypto.olmDevice;
 
         const roomId = "!someroom";
 
-        aliceClient._crypto._onToDeviceEvent(new MatrixEvent({
+        aliceClient.crypto.onToDeviceEvent(new MatrixEvent({
             type: "org.matrix.room_key.withheld",
             sender: "@bob:example.com",
             content: {
@@ -576,7 +626,7 @@ describe("MegolmDecryption", function() {
             },
         }));
 
-        await expect(aliceClient._crypto.decryptEvent(new MatrixEvent({
+        await expect(aliceClient.crypto.decryptEvent(new MatrixEvent({
             type: "m.room.encrypted",
             sender: "@bob:example.com",
             event_id: "$event",
@@ -602,14 +652,14 @@ describe("MegolmDecryption", function() {
             aliceClient.initCrypto(),
             bobClient.initCrypto(),
         ]);
-        aliceClient._crypto.downloadKeys = async () => {};
-        const bobDevice = bobClient._crypto._olmDevice;
+        aliceClient.crypto.downloadKeys = async () => {};
+        const bobDevice = bobClient.crypto.olmDevice;
 
         const roomId = "!someroom";
 
         const now = Date.now();
 
-        aliceClient._crypto._onToDeviceEvent(new MatrixEvent({
+        aliceClient.crypto.onToDeviceEvent(new MatrixEvent({
             type: "org.matrix.room_key.withheld",
             sender: "@bob:example.com",
             content: {
@@ -626,7 +676,7 @@ describe("MegolmDecryption", function() {
             setTimeout(resolve, 100);
         });
 
-        await expect(aliceClient._crypto.decryptEvent(new MatrixEvent({
+        await expect(aliceClient.crypto.decryptEvent(new MatrixEvent({
             type: "m.room.encrypted",
             sender: "@bob:example.com",
             event_id: "$event",
@@ -653,15 +703,15 @@ describe("MegolmDecryption", function() {
             aliceClient.initCrypto(),
             bobClient.initCrypto(),
         ]);
-        const bobDevice = bobClient._crypto._olmDevice;
-        aliceClient._crypto.downloadKeys = async () => {};
+        const bobDevice = bobClient.crypto.olmDevice;
+        aliceClient.crypto.downloadKeys = async () => {};
 
         const roomId = "!someroom";
 
         const now = Date.now();
 
         // pretend we got an event that we can't decrypt
-        aliceClient._crypto._onToDeviceEvent(new MatrixEvent({
+        aliceClient.crypto.onToDeviceEvent(new MatrixEvent({
             type: "m.room.encrypted",
             sender: "@bob:example.com",
             content: {
@@ -676,7 +726,7 @@ describe("MegolmDecryption", function() {
             setTimeout(resolve, 100);
         });
 
-        await expect(aliceClient._crypto.decryptEvent(new MatrixEvent({
+        await expect(aliceClient.crypto.decryptEvent(new MatrixEvent({
             type: "m.room.encrypted",
             sender: "@bob:example.com",
             event_id: "$event",

spec/unit/crypto/algorithms/olm.spec.js

@@ -16,12 +16,12 @@ limitations under the License.
 */
 
 import '../../../olm-loader';
-import {MemoryCryptoStore} from "../../../../src/crypto/store/memory-crypto-store";
-import {MockStorageApi} from "../../../MockStorageApi";
-import {logger} from "../../../../src/logger";
-import {OlmDevice} from "../../../../src/crypto/OlmDevice";
+import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
+import { MockStorageApi } from "../../../MockStorageApi";
+import { logger } from "../../../../src/logger";
+import { OlmDevice } from "../../../../src/crypto/OlmDevice";
 import * as olmlib from "../../../../src/crypto/olmlib";
-import {DeviceInfo} from "../../../../src/crypto/deviceinfo";
+import { DeviceInfo } from "../../../../src/crypto/deviceinfo";
 
 function makeOlmDevice() {
     const mockStorage = new MockStorageApi();
@@ -190,5 +190,91 @@ describe("OlmDevice", function() {
             // 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);
+                    });
+                },
+            };
+
+            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);
+        });
     });
 });

spec/unit/crypto/backup.spec.js

@@ -16,17 +16,19 @@ limitations under the License.
 */
 
 import '../../olm-loader';
-import {logger} from "../../../src/logger";
+import { logger } from "../../../src/logger";
 import * as olmlib from "../../../src/crypto/olmlib";
-import {MatrixClient} from "../../../src/client";
-import {MatrixEvent} from "../../../src/models/event";
+import { MatrixClient } from "../../../src/client";
+import { MatrixEvent } from "../../../src/models/event";
 import * as algorithms from "../../../src/crypto/algorithms";
-import {WebStorageSessionStore} from "../../../src/store/session/webstorage";
-import {MemoryCryptoStore} from "../../../src/crypto/store/memory-crypto-store";
-import {MockStorageApi} from "../../MockStorageApi";
+import { WebStorageSessionStore } from "../../../src/store/session/webstorage";
+import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
+import { MockStorageApi } from "../../MockStorageApi";
 import * as testUtils from "../../test-utils";
-import {OlmDevice} from "../../../src/crypto/OlmDevice";
-import {Crypto} from "../../../src/crypto";
+import { OlmDevice } from "../../../src/crypto/OlmDevice";
+import { Crypto } from "../../../src/crypto";
+import { resetCrossSigningKeys } from "./crypto-utils";
+import { BackupManager } from "../../../src/crypto/backup";
 
 const Olm = global.Olm;
 
@@ -50,7 +52,7 @@ const ENCRYPTED_EVENT = new MatrixEvent({
     origin_server_ts: 1507753886000,
 });
 
-const KEY_BACKUP_DATA = {
+const CURVE25519_KEY_BACKUP_DATA = {
     first_message_index: 0,
     forwarded_count: 0,
     is_verified: false,
@@ -71,14 +73,41 @@ const KEY_BACKUP_DATA = {
     },
 };
 
-const BACKUP_INFO = {
-    algorithm: "m.megolm_backup.v1",
+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: "m.megolm_backup.v1.curve25519-aes-sha2",
     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) {
@@ -137,11 +166,12 @@ describe("MegolmBackup", function() {
     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 = BACKUP_INFO;
+        mockCrypto.backupInfo = CURVE25519_BACKUP_INFO;
 
         mockStorage = new MockStorageApi();
         sessionStore = new WebStorageSessionStore(mockStorage);
@@ -214,16 +244,18 @@ describe("MegolmBackup", function() {
             };
             mockCrypto.cancelRoomKeyRequest = function() {};
 
-            mockCrypto.backupGroupSession = jest.fn();
+            mockCrypto.backupManager = {
+                backupGroupSession: jest.fn(),
+            };
 
             return event.attemptDecryption(mockCrypto).then(() => {
                 return megolmDecryption.onRoomKeyEvent(event);
             }).then(() => {
-                expect(mockCrypto.backupGroupSession).toHaveBeenCalled();
+                expect(mockCrypto.backupManager.backupGroupSession).toHaveBeenCalled();
             });
         });
 
-        it('sends backups to the server', function() {
+        it('sends backups to the server (Curve25519 version)', function() {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
             const ibGroupSession = new Olm.InboundGroupSession();
@@ -256,14 +288,14 @@ describe("MegolmBackup", function() {
                                         ed25519: "SENDER_ED25519",
                                     },
                                     room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice._pickleKey),
+                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
                                 },
                                 txn);
                         });
                 })
                 .then(() => {
                     client.enableKeyBackup({
-                        algorithm: "m.megolm_backup.v1",
+                        algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
                         version: 1,
                         auth_data: {
                             public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
@@ -271,7 +303,7 @@ describe("MegolmBackup", function() {
                     });
                     let numCalls = 0;
                     return new Promise((resolve, reject) => {
-                        client._http.authedRequest = function(
+                        client.http.authedRequest = function(
                             callback, method, path, queryParams, data, opts,
                         ) {
                             ++numCalls;
@@ -291,12 +323,91 @@ describe("MegolmBackup", function() {
                             resolve();
                             return Promise.resolve({});
                         };
-                        client._crypto.backupGroupSession(
-                            "roomId",
+                        client.crypto.backupManager.backupGroupSession(
+                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                            groupSession.session_id(),
+                        );
+                    }).then(() => {
+                        expect(numCalls).toBe(1);
+                    });
+                });
+        });
+
+        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(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 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(() => {
+                    client.enableKeyBackup({
+                        algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
+                        version: 1,
+                        auth_data: {
+                            iv: "PsCAtR7gMc4xBd9YS3A9Ow",
+                            mac: "ZSDsTFEZK7QzlauCLMleUcX96GQZZM7UNtk4sripSqQ",
+                        },
+                    });
+                    let numCalls = 0;
+                    return new Promise((resolve, reject) => {
+                        client.http.authedRequest = function(
+                            callback, method, path, queryParams, data, opts,
+                        ) {
+                            ++numCalls;
+                            expect(numCalls).toBeLessThanOrEqual(1);
+                            if (numCalls >= 2) {
+                                // exit out of retry loop if there's something wrong
+                                reject(new Error("authedRequest called too many timmes"));
+                                return Promise.resolve({});
+                            }
+                            expect(method).toBe("PUT");
+                            expect(path).toBe("/room_keys/keys");
+                            expect(queryParams.version).toBe(1);
+                            expect(data.rooms[ROOM_ID].sessions).toBeDefined();
+                            expect(data.rooms[ROOM_ID].sessions).toHaveProperty(
+                                groupSession.session_id(),
+                            );
+                            resolve();
+                            return Promise.resolve({});
+                        };
+                        client.crypto.backupManager.backupGroupSession(
                             "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                            [],
                             groupSession.session_id(),
-                            groupSession.session_key(),
                         );
                     }).then(() => {
                         expect(numCalls).toBe(1);
@@ -332,41 +443,50 @@ describe("MegolmBackup", function() {
             client.on("crossSigning.getKey", function(e) {
                 e.done(privateKeys[e.type]);
             });
-            await client.resetCrossSigningKeys();
+            await resetCrossSigningKeys(client);
             let numCalls = 0;
-            await new Promise((resolve, reject) => {
-                client._http.authedRequest = function(
-                    callback, method, path, queryParams, data, opts,
-                ) {
-                    ++numCalls;
-                    expect(numCalls).toBeLessThanOrEqual(1);
-                    if (numCalls >= 2) {
-                        // exit out of retry loop if there's something wrong
-                        reject(new Error("authedRequest called too many timmes"));
-                        return Promise.resolve({});
-                    }
-                    expect(method).toBe("POST");
-                    expect(path).toBe("/room_keys/version");
-                    try {
-                        // make sure auth_data is signed by the master key
-                        olmlib.pkVerify(
-                            data.auth_data, client.getCrossSigningId(), "@alice:bar",
-                        );
-                    } catch (e) {
-                        reject(e);
-                        return Promise.resolve({});
-                    }
-                    resolve();
-                    return Promise.resolve({});
-                };
+            await Promise.all([
+                new Promise((resolve, reject) => {
+                    let backupInfo;
+                    client.http.authedRequest = function(
+                        callback, 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.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: "m.megolm_backup.v1",
+                    algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
                     auth_data: {
                         public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
                     },
-                });
-            });
-            expect(numCalls).toBe(1);
+                }),
+            ]);
+            expect(numCalls).toBe(2);
         });
 
         it('retries when a backup fails', function() {
@@ -426,14 +546,14 @@ describe("MegolmBackup", function() {
                                         ed25519: "SENDER_ED25519",
                                     },
                                     room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice._pickleKey),
+                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
                                 },
                                 txn);
                         });
                 })
                 .then(() => {
                     client.enableKeyBackup({
-                        algorithm: "foobar",
+                        algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
                         version: 1,
                         auth_data: {
                             public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
@@ -441,7 +561,7 @@ describe("MegolmBackup", function() {
                     });
                     let numCalls = 0;
                     return new Promise((resolve, reject) => {
-                        client._http.authedRequest = function(
+                        client.http.authedRequest = function(
                             callback, method, path, queryParams, data, opts,
                         ) {
                             ++numCalls;
@@ -467,12 +587,9 @@ describe("MegolmBackup", function() {
                                 );
                             }
                         };
-                        client._crypto.backupGroupSession(
-                            "roomId",
+                        client.crypto.backupManager.backupGroupSession(
                             "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                            [],
                             groupSession.session_id(),
-                            groupSession.session_key(),
                         );
                     }).then(() => {
                         expect(numCalls).toBe(2);
@@ -504,29 +621,47 @@ describe("MegolmBackup", function() {
             client.stopClient();
         });
 
-        it('can restore from backup', function() {
-            client._http.authedRequest = function() {
-                return Promise.resolve(KEY_BACKUP_DATA);
+        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,
-                BACKUP_INFO,
+                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 backup by room', function() {
-            client._http.authedRequest = function() {
+        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]: KEY_BACKUP_DATA,
+                                [SESSION_ID]: CURVE25519_KEY_BACKUP_DATA,
                             },
                         },
                     },
@@ -534,7 +669,7 @@ describe("MegolmBackup", function() {
             };
             return client.restoreKeyBackupWithRecoveryKey(
                 "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                null, null, BACKUP_INFO,
+                null, null, CURVE25519_BACKUP_INFO,
             ).then(() => {
                 return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
             }).then((res) => {
@@ -544,28 +679,44 @@ describe("MegolmBackup", function() {
 
         it('has working cache functions', async function() {
             const key = Uint8Array.from([1, 2, 3, 4, 5, 6, 7, 8]);
-            await client._crypto.storeSessionBackupPrivateKey(key);
-            const result = await client._crypto.getSessionBackupPrivateKey();
-            expect(result).toEqual(key);
+            await client.crypto.storeSessionBackupPrivateKey(key);
+            const result = await client.crypto.getSessionBackupPrivateKey();
+            expect(new Uint8Array(result)).toEqual(key);
         });
 
         it('caches session backup keys as it encounters them', async function() {
-            const cachedNull = await client._crypto.getSessionBackupPrivateKey();
+            const cachedNull = await client.crypto.getSessionBackupPrivateKey();
             expect(cachedNull).toBeNull();
-            client._http.authedRequest = function() {
-                return Promise.resolve(KEY_BACKUP_DATA);
+            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,
-                    BACKUP_INFO,
+                    CURVE25519_BACKUP_INFO,
                     { cacheCompleteCallback: resolve },
                 );
             });
-            const cachedKey = await client._crypto.getSessionBackupPrivateKey();
+            const cachedKey = await client.crypto.getSessionBackupPrivateKey();
             expect(cachedKey).not.toBeNull();
         });
+
+        it("fails if an known algorithm is used", async function() {
+            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();
+        });
     });
 });

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

@@ -18,8 +18,11 @@ limitations under the License.
 import '../../olm-loader';
 import anotherjson from 'another-json';
 import * as olmlib from "../../../src/crypto/olmlib";
-import {TestClient} from '../../TestClient';
-import {HttpResponse, setHttpResponses} from '../../test-utils';
+import { TestClient } from '../../TestClient';
+import { HttpResponse, setHttpResponses } from '../../test-utils';
+import { resetCrossSigningKeys } from "./crypto-utils";
+import { MatrixError } from '../../../src/http-api';
+import { logger } from '../../../src/logger';
 
 async function makeTestClient(userInfo, options, keys) {
     if (!keys) keys = {};
@@ -47,7 +50,7 @@ async function makeTestClient(userInfo, options, keys) {
 
 describe("Cross Signing", function() {
     if (!global.Olm) {
-        console.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn('Not running megolm backup unit tests: libolm not present');
         return;
     }
 
@@ -57,30 +60,85 @@ describe("Cross Signing", function() {
 
     it("should sign the master key with the device key", async function() {
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
         );
         alice.uploadDeviceSigningKeys = jest.fn(async (auth, keys) => {
             await olmlib.verifySignature(
-                alice._crypto._olmDevice, keys.master_key, "@alice:example.com",
-                "Osborne2", alice._crypto._olmDevice.deviceEd25519Key,
+                alice.crypto.olmDevice, keys.master_key, "@alice:example.com",
+                "Osborne2", alice.crypto.olmDevice.deviceEd25519Key,
             );
         });
         alice.uploadKeySignatures = async () => {};
+        alice.setAccountData = async () => {};
+        alice.getAccountDataFromServer = async () => {};
         // set Alice's cross-signing key
-        await alice.resetCrossSigningKeys();
+        await alice.bootstrapCrossSigning({
+            authUploadDeviceSigningKeys: async func => await func({}),
+        });
         expect(alice.uploadDeviceSigningKeys).toHaveBeenCalled();
     });
 
+    it("should abort bootstrap if device signing auth fails", async function() {
+        const alice = await makeTestClient(
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
+        );
+        alice.uploadDeviceSigningKeys = async (auth, keys) => {
+            const errorResponse = {
+                session: "sessionId",
+                flows: [
+                    {
+                        stages: [
+                            "m.login.password",
+                        ],
+                    },
+                ],
+                params: {},
+            };
+
+            // If we're not just polling for flows, add on error rejecting the
+            // auth attempt.
+            if (auth) {
+                Object.assign(errorResponse, {
+                    completed: [],
+                    error: "Invalid password",
+                    errcode: "M_FORBIDDEN",
+                });
+            }
+
+            const error = new MatrixError(errorResponse);
+            error.httpStatus == 401;
+            throw error;
+        };
+        alice.uploadKeySignatures = async () => {};
+        alice.setAccountData = async () => {};
+        alice.getAccountDataFromServer = async () => { };
+        const authUploadDeviceSigningKeys = async func => await func({});
+
+        // Try bootstrap, expecting `authUploadDeviceSigningKeys` to pass
+        // through failure, stopping before actually applying changes.
+        let bootstrapDidThrow = false;
+        try {
+            await alice.bootstrapCrossSigning({
+                authUploadDeviceSigningKeys,
+            });
+        } catch (e) {
+            if (e.errcode === "M_FORBIDDEN") {
+                bootstrapDidThrow = true;
+            }
+        }
+        expect(bootstrapDidThrow).toBeTruthy();
+    });
+
     it("should upload a signature when a user is verified", async function() {
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
         );
         alice.uploadDeviceSigningKeys = async () => {};
         alice.uploadKeySignatures = async () => {};
         // set Alice's cross-signing key
-        await alice.resetCrossSigningKeys();
+        await resetCrossSigningKeys(alice);
         // Alice downloads Bob's device key
-        alice._crypto._deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -117,7 +175,7 @@ describe("Cross Signing", function() {
         ]);
 
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
             {
                 cryptoCallbacks: {
                     // will be called to sign our own device
@@ -135,30 +193,36 @@ describe("Cross Signing", function() {
         const keyChangePromise = new Promise((resolve, reject) => {
             alice.once("crossSigning.keysChanged", async (e) => {
                 resolve(e);
-                await alice.checkOwnCrossSigningTrust();
+                await alice.checkOwnCrossSigningTrust({
+                    allowPrivateKeyRequests: true,
+                });
             });
         });
 
         const uploadSigsPromise = new Promise((resolve, reject) => {
             alice.uploadKeySignatures = jest.fn(async (content) => {
-                await olmlib.verifySignature(
-                    alice._crypto._olmDevice,
-                    content["@alice:example.com"][
-                        "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk"
-                    ],
-                    "@alice:example.com",
-                    "Osborne2", alice._crypto._olmDevice.deviceEd25519Key,
-                );
-                olmlib.pkVerify(
-                    content["@alice:example.com"]["Osborne2"],
-                    "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
-                    "@alice:example.com",
-                );
-                resolve();
+                try {
+                    await olmlib.verifySignature(
+                        alice.crypto.olmDevice,
+                        content["@alice:example.com"][
+                            "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk"
+                            ],
+                        "@alice:example.com",
+                        "Osborne2", alice.crypto.olmDevice.deviceEd25519Key,
+                    );
+                    olmlib.pkVerify(
+                        content["@alice:example.com"]["Osborne2"],
+                        "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
+                        "@alice:example.com",
+                    );
+                    resolve();
+                } catch (e) {
+                    reject(e);
+                }
             });
         });
 
-        const deviceInfo = alice._crypto._deviceList._devices["@alice:example.com"]
+        const deviceInfo = alice.crypto.deviceList.devices["@alice:example.com"]
             .Osborne2;
         const aliceDevice = {
             user_id: "@alice:example.com",
@@ -166,7 +230,7 @@ describe("Cross Signing", function() {
         };
         aliceDevice.keys = deviceInfo.keys;
         aliceDevice.algorithms = deviceInfo.algorithms;
-        await alice._crypto._signObject(aliceDevice);
+        await alice.crypto.signObject(aliceDevice);
         olmlib.pkSign(aliceDevice, selfSigningKey, "@alice:example.com");
 
         // feed sync result that includes master key, ssk, device key
@@ -268,12 +332,12 @@ describe("Cross Signing", function() {
 
     it("should use trust chain to determine device verification", async function() {
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
         );
         alice.uploadDeviceSigningKeys = async () => {};
         alice.uploadKeySignatures = async () => {};
         // set Alice's cross-signing key
-        await alice.resetCrossSigningKeys();
+        await resetCrossSigningKeys(alice);
         // Alice downloads Bob's ssk and device key
         const bobMasterSigning = new global.Olm.PkSigning();
         const bobMasterPrivkey = bobMasterSigning.generate_seed();
@@ -294,7 +358,7 @@ describe("Cross Signing", function() {
                 ["ed25519:" + bobMasterPubkey]: sskSig,
             },
         };
-        alice._crypto._deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -323,7 +387,7 @@ describe("Cross Signing", function() {
                 ["ed25519:" + bobPubkey]: sig,
             },
         };
-        alice._crypto._deviceList.storeDevicesForUser("@bob:example.com", {
+        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: bobDevice,
         });
         // Bob's device key should be TOFU
@@ -353,17 +417,17 @@ describe("Cross Signing", function() {
     it("should trust signatures received from other devices", async function() {
         const aliceKeys = {};
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
             null,
             aliceKeys,
         );
-        alice._crypto._deviceList.startTrackingDeviceList("@bob:example.com");
-        alice._crypto._deviceList.stopTrackingAllDeviceLists = () => {};
+        alice.crypto.deviceList.startTrackingDeviceList("@bob:example.com");
+        alice.crypto.deviceList.stopTrackingAllDeviceLists = () => {};
         alice.uploadDeviceSigningKeys = async () => {};
         alice.uploadKeySignatures = async () => {};
 
         // set Alice's cross-signing key
-        await alice.resetCrossSigningKeys();
+        await resetCrossSigningKeys(alice);
 
         const selfSigningKey = new Uint8Array([
             0x1e, 0xf4, 0x01, 0x6d, 0x4f, 0xa1, 0x73, 0x66,
@@ -373,14 +437,14 @@ describe("Cross Signing", function() {
         ]);
 
         const keyChangePromise = new Promise((resolve, reject) => {
-            alice._crypto._deviceList.once("userCrossSigningUpdated", (userId) => {
+            alice.crypto.deviceList.once("userCrossSigningUpdated", (userId) => {
                 if (userId === "@bob:example.com") {
                     resolve();
                 }
             });
         });
 
-        const deviceInfo = alice._crypto._deviceList._devices["@alice:example.com"]
+        const deviceInfo = alice.crypto.deviceList.devices["@alice:example.com"]
             .Osborne2;
         const aliceDevice = {
             user_id: "@alice:example.com",
@@ -388,7 +452,7 @@ describe("Cross Signing", function() {
         };
         aliceDevice.keys = deviceInfo.keys;
         aliceDevice.algorithms = deviceInfo.algorithms;
-        await alice._crypto._signObject(aliceDevice);
+        await alice.crypto.signObject(aliceDevice);
 
         const bobOlmAccount = new global.Olm.Account();
         bobOlmAccount.create();
@@ -515,12 +579,12 @@ describe("Cross Signing", function() {
 
     it("should dis-trust an unsigned device", async function() {
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
         );
         alice.uploadDeviceSigningKeys = async () => {};
         alice.uploadKeySignatures = async () => {};
         // set Alice's cross-signing key
-        await alice.resetCrossSigningKeys();
+        await resetCrossSigningKeys(alice);
         // Alice downloads Bob's ssk and device key
         // (NOTE: device key is not signed by ssk)
         const bobMasterSigning = new global.Olm.PkSigning();
@@ -542,7 +606,7 @@ describe("Cross Signing", function() {
                 ["ed25519:" + bobMasterPubkey]: sskSig,
             },
         };
-        alice._crypto._deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -565,7 +629,7 @@ describe("Cross Signing", function() {
                 "ed25519:Dynabook": "someOtherPubkey",
             },
         };
-        alice._crypto._deviceList.storeDevicesForUser("@bob:example.com", {
+        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: bobDevice,
         });
         // Bob's device key should be untrusted
@@ -584,11 +648,11 @@ describe("Cross Signing", function() {
 
     it("should dis-trust a user when their ssk changes", async function() {
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
         );
         alice.uploadDeviceSigningKeys = async () => {};
         alice.uploadKeySignatures = async () => {};
-        await alice.resetCrossSigningKeys();
+        await resetCrossSigningKeys(alice);
         // Alice downloads Bob's keys
         const bobMasterSigning = new global.Olm.PkSigning();
         const bobMasterPrivkey = bobMasterSigning.generate_seed();
@@ -609,7 +673,7 @@ describe("Cross Signing", function() {
                 ["ed25519:" + bobMasterPubkey]: sskSig,
             },
         };
-        alice._crypto._deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -637,7 +701,7 @@ describe("Cross Signing", function() {
         bobDevice.signatures = {};
         bobDevice.signatures["@bob:example.com"] = {};
         bobDevice.signatures["@bob:example.com"]["ed25519:" + bobPubkey] = sig;
-        alice._crypto._deviceList.storeDevicesForUser("@bob:example.com", {
+        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: bobDevice,
         });
         // Alice verifies Bob's SSK
@@ -669,7 +733,7 @@ describe("Cross Signing", function() {
                 ["ed25519:" + bobMasterPubkey2]: sskSig2,
             },
         };
-        alice._crypto._deviceList.storeCrossSigningForUser("@bob:example.com", {
+        alice.crypto.deviceList.storeCrossSigningForUser("@bob:example.com", {
             keys: {
                 master: {
                     user_id: "@bob:example.com",
@@ -706,7 +770,7 @@ describe("Cross Signing", function() {
         // Alice gets new signature for device
         const sig2 = bobSigning2.sign(bobDeviceString);
         bobDevice.signatures["@bob:example.com"]["ed25519:" + bobPubkey2] = sig2;
-        alice._crypto._deviceList.storeDevicesForUser("@bob:example.com", {
+        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: bobDevice,
         });
 
@@ -722,7 +786,7 @@ describe("Cross Signing", function() {
         let upgradeResolveFunc;
 
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
             {
                 cryptoCallbacks: {
                     shouldUpgradeDeviceVerifications: (verifs) => {
@@ -734,27 +798,27 @@ describe("Cross Signing", function() {
             },
         );
         const bob = await makeTestClient(
-            {userId: "@bob:example.com", deviceId: "Dynabook"},
+            { userId: "@bob:example.com", deviceId: "Dynabook" },
         );
 
         bob.uploadDeviceSigningKeys = async () => {};
         bob.uploadKeySignatures = async () => {};
         // set Bob's cross-signing key
-        await bob.resetCrossSigningKeys();
-        alice._crypto._deviceList.storeDevicesForUser("@bob:example.com", {
+        await resetCrossSigningKeys(bob);
+        alice.crypto.deviceList.storeDevicesForUser("@bob:example.com", {
             Dynabook: {
                 algorithms: ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
                 keys: {
-                    "curve25519:Dynabook": bob._crypto._olmDevice.deviceCurve25519Key,
-                    "ed25519:Dynabook": bob._crypto._olmDevice.deviceEd25519Key,
+                    "curve25519:Dynabook": bob.crypto.olmDevice.deviceCurve25519Key,
+                    "ed25519:Dynabook": bob.crypto.olmDevice.deviceEd25519Key,
                 },
                 verified: 1,
                 known: true,
             },
         });
-        alice._crypto._deviceList.storeCrossSigningForUser(
+        alice.crypto.deviceList.storeCrossSigningForUser(
             "@bob:example.com",
-            bob._crypto._crossSigningInfo.toStorage(),
+            bob.crypto.crossSigningInfo.toStorage(),
         );
 
         alice.uploadDeviceSigningKeys = async () => {};
@@ -766,7 +830,7 @@ describe("Cross Signing", function() {
         let upgradePromise = new Promise((resolve) => {
             upgradeResolveFunc = resolve;
         });
-        await alice.resetCrossSigningKeys();
+        await resetCrossSigningKeys(alice);
         await upgradePromise;
 
         const bobTrust = alice.checkUserTrust("@bob:example.com");
@@ -774,7 +838,7 @@ describe("Cross Signing", function() {
         expect(bobTrust.isTofu()).toBeTruthy();
 
         // "forget" that Bob is trusted
-        delete alice._crypto._deviceList._crossSigningInfo["@bob:example.com"]
+        delete alice.crypto.deviceList.crossSigningInfo["@bob:example.com"]
             .keys.master.signatures["@alice:example.com"];
 
         const bobTrust2 = alice.checkUserTrust("@bob:example.com");
@@ -784,9 +848,9 @@ describe("Cross Signing", function() {
         upgradePromise = new Promise((resolve) => {
             upgradeResolveFunc = resolve;
         });
-        alice._crypto._deviceList.emit("userCrossSigningUpdated", "@bob:example.com");
+        alice.crypto.deviceList.emit("userCrossSigningUpdated", "@bob:example.com");
         await new Promise((resolve) => {
-            alice._crypto.on("userTrustStatusChanged", resolve);
+            alice.crypto.on("userTrustStatusChanged", resolve);
         });
         await upgradePromise;
 

spec/unit/crypto/crypto-utils.js

@@ -0,0 +1,43 @@
+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,
+    authUploadDeviceSigningKeys = async func => await func(),
+} = {}) {
+    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.baseApis.emit("crossSigning.keysChanged", {});
+    await crypto.afterCrossSigningLocalKeyChange();
+}
+
+export async function createSecretStorageKey() {
+    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 },
+        privateKey: storagePrivateKey,
+    };
+}

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

@@ -0,0 +1,85 @@
+/*
+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 {
+    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 { RoomKeyRequestState } from '../../../src/crypto/OutgoingRoomKeyRequestManager';
+
+const requests = [
+    {
+        requestId: "A",
+        requestBody: { session_id: "A", room_id: "A" },
+        state: RoomKeyRequestState.Sent,
+    },
+    {
+        requestId: "B",
+        requestBody: { session_id: "B", room_id: "B" },
+        state: RoomKeyRequestState.Sent,
+    },
+    {
+        requestId: "C",
+        requestBody: { session_id: "C", room_id: "C" },
+        state: RoomKeyRequestState.Unsent,
+    },
+];
+
+describe.each([
+    ["IndexedDBCryptoStore",
+     () => new IndexedDBCryptoStore(global.indexedDB, "tests")],
+    ["LocalStorageCryptoStore",
+     () => new IndexedDBCryptoStore(undefined, "tests")],
+    ["MemoryCryptoStore", () => {
+        const store = new IndexedDBCryptoStore(undefined, "tests");
+        store._backend = new MemoryCryptoStore();
+        store._backendPromise = Promise.resolve(store._backend);
+        return store;
+    }],
+])("Outgoing room key requests [%s]", function(name, dbFactory) {
+    let store;
+
+    beforeAll(async () => {
+        store = dbFactory();
+        await store.startup();
+        await Promise.all(requests.map((request) =>
+            store.getOrAddOutgoingRoomKeyRequest(request),
+        ));
+    });
+
+    it("getAllOutgoingRoomKeyRequestsByState retrieves all entries in a given state",
+    async () => {
+        const r = await
+            store.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);
+        expect(r).toHaveLength(2);
+        requests.filter((e) => e.state === RoomKeyRequestState.Sent).forEach((e) => {
+            expect(r).toContainEqual(e);
+        });
+    });
+
+    test("getOutgoingRoomKeyRequestByState retrieves any entry in a given state",
+    async () => {
+        const r =
+            await store.getOutgoingRoomKeyRequestByState([RoomKeyRequestState.Sent]);
+        expect(r).not.toBeNull();
+        expect(r).not.toBeUndefined();
+        expect(r.state).toEqual(RoomKeyRequestState.Sent);
+        expect(requests).toContainEqual(r);
+    });
+});

spec/unit/crypto/secrets.spec.js

@@ -16,10 +16,13 @@ limitations under the License.
 
 import '../../olm-loader';
 import * as olmlib from "../../../src/crypto/olmlib";
-import {SECRET_STORAGE_ALGORITHM_V1_AES} from "../../../src/crypto/SecretStorage";
-import {MatrixEvent} from "../../../src/models/event";
-import {TestClient} from '../../TestClient';
-import {makeTestClients} from './verification/util';
+import { SECRET_STORAGE_ALGORITHM_V1_AES } from "../../../src/crypto/SecretStorage";
+import { MatrixEvent } from "../../../src/models/event";
+import { TestClient } from '../../TestClient';
+import { makeTestClients } from './verification/util';
+import { encryptAES } from "../../../src/crypto/aes";
+import { resetCrossSigningKeys, createSecretStorageKey } from "./crypto-utils";
+import { logger } from '../../../src/logger';
 
 import * as utils from "../../../src/utils";
 
@@ -27,7 +30,7 @@ try {
     const crypto = require('crypto');
     utils.setCrypto(crypto);
 } catch (err) {
-    console.log('nodejs was compiled without crypto support');
+    logger.log('nodejs was compiled without crypto support');
 }
 
 async function makeTestClient(userInfo, options) {
@@ -44,14 +47,21 @@ async function makeTestClient(userInfo, options) {
     await client.initCrypto();
 
     // No need to download keys for these tests
-    client._crypto.downloadKeys = async function() {};
+    client.crypto.downloadKeys = async function() {};
 
     return client;
 }
 
+// Wrapper around pkSign to return a signed object. pkSign returns the
+// signature, rather than the signed object.
+function sign(obj, key, userId) {
+    olmlib.pkSign(obj, key, userId);
+    return obj;
+}
+
 describe("Secrets", function() {
     if (!global.Olm) {
-        console.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn('Not running megolm backup unit tests: libolm not present');
         return;
     }
 
@@ -81,7 +91,7 @@ describe("Secrets", function() {
         });
 
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
             {
                 cryptoCallbacks: {
                     getCrossSigningKey: t => signingKey,
@@ -89,11 +99,11 @@ describe("Secrets", function() {
                 },
             },
         );
-        alice._crypto._crossSigningInfo.setKeys({
+        alice.crypto.crossSigningInfo.setKeys({
             master: signingkeyInfo,
         });
 
-        const secretStorage = alice._crypto._secretStorage;
+        const secretStorage = alice.crypto.secretStorage;
 
         alice.setAccountData = async function(eventType, contents, callback) {
             alice.store.storeAccountDataEvents([
@@ -110,7 +120,7 @@ describe("Secrets", function() {
         const keyAccountData = {
             algorithm: SECRET_STORAGE_ALGORITHM_V1_AES,
         };
-        await alice._crypto._crossSigningInfo.signObject(keyAccountData, 'master');
+        await alice.crypto.crossSigningInfo.signObject(keyAccountData, 'master');
 
         alice.store.storeAccountDataEvents([
             new MatrixEvent({
@@ -131,7 +141,7 @@ describe("Secrets", function() {
 
     it("should throw if given a key that doesn't exist", async function() {
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
         );
 
         try {
@@ -145,7 +155,7 @@ describe("Secrets", function() {
 
     it("should refuse to encrypt with zero keys", async function() {
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
         );
 
         try {
@@ -165,7 +175,7 @@ describe("Secrets", function() {
 
         let keys = {};
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
             {
                 cryptoCallbacks: {
                     getCrossSigningKey: t => keys[t],
@@ -182,9 +192,9 @@ describe("Secrets", function() {
                 }),
             ]);
         };
-        alice.resetCrossSigningKeys();
+        resetCrossSigningKeys(alice);
 
-        const newKeyId = await alice.addSecretStorageKey(
+        const { keyId: newKeyId } = await alice.addSecretStorageKey(
             SECRET_STORAGE_ALGORITHM_V1_AES,
         );
         // we don't await on this because it waits for the event to come down the sync
@@ -198,7 +208,7 @@ describe("Secrets", function() {
 
     it("should refuse to encrypt if no keys given and no default key", async function() {
         const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
         );
 
         try {
@@ -211,24 +221,24 @@ describe("Secrets", function() {
     it("should request secrets from other clients", async function() {
         const [osborne2, vax] = await makeTestClients(
             [
-                {userId: "@alice:example.com", deviceId: "Osborne2"},
-                {userId: "@alice:example.com", deviceId: "VAX"},
+                { userId: "@alice:example.com", deviceId: "Osborne2" },
+                { userId: "@alice:example.com", deviceId: "VAX" },
             ],
             {
                 cryptoCallbacks: {
-                    onSecretRequested: e => {
-                        expect(e.name).toBe("foo");
+                    onSecretRequested: (userId, deviceId, requestId, secretName, deviceTrust) => {
+                        expect(secretName).toBe("foo");
                         return "bar";
                     },
                 },
             },
         );
 
-        const vaxDevice = vax.client._crypto._olmDevice;
-        const osborne2Device = osborne2.client._crypto._olmDevice;
-        const secretStorage = osborne2.client._crypto._secretStorage;
+        const vaxDevice = vax.client.crypto.olmDevice;
+        const osborne2Device = osborne2.client.crypto.olmDevice;
+        const secretStorage = osborne2.client.crypto.secretStorage;
 
-        osborne2.client._crypto._deviceList.storeDevicesForUser("@alice:example.com", {
+        osborne2.client.crypto.deviceList.storeDevicesForUser("@alice:example.com", {
             "VAX": {
                 user_id: "@alice:example.com",
                 device_id: "VAX",
@@ -239,7 +249,7 @@ describe("Secrets", function() {
                 },
             },
         });
-        vax.client._crypto._deviceList.storeDevicesForUser("@alice:example.com", {
+        vax.client.crypto.deviceList.storeDevicesForUser("@alice:example.com", {
             "Osborne2": {
                 user_id: "@alice:example.com",
                 device_id: "Osborne2",
@@ -255,7 +265,7 @@ describe("Secrets", function() {
         const otks = (await osborne2Device.getOneTimeKeys()).curve25519;
         await osborne2Device.markKeysAsPublished();
 
-        await vax.client._crypto._olmDevice.createOutboundSession(
+        await vax.client.crypto.olmDevice.createOutboundSession(
             osborne2Device.deviceCurve25519Key,
             Object.values(otks)[0],
         );
@@ -266,100 +276,399 @@ describe("Secrets", function() {
         expect(secret).toBe("bar");
     });
 
-    it("bootstraps when no storage or cross-signing keys locally", async function() {
-        const key = new Uint8Array(16);
-        for (let i = 0; i < 16; i++) key[i] = i;
-        const getKey = jest.fn(e => {
-            return [Object.keys(e.keys)[0], key];
-        });
-
-        const bob = await makeTestClient(
-            {
-                userId: "@bob:example.com",
-                deviceId: "bob1",
-            },
-            {
-                cryptoCallbacks: {
-                    getSecretStorageKey: getKey,
-                },
-            },
+    describe("bootstrap", function() {
+        // keys used in some of the tests
+        const XSK = new Uint8Array(
+            olmlib.decodeBase64("3lo2YdJugHjfE+Or7KJ47NuKbhE7AAGLgQ/dc19913Q="),
         );
-        bob.uploadDeviceSigningKeys = async () => {};
-        bob.uploadKeySignatures = async () => {};
-        bob.setAccountData = async function(eventType, contents, callback) {
-            const event = new MatrixEvent({
-                type: eventType,
-                content: contents,
+        const XSPubKey = "DRb8pFVJyEJ9OWvXeUoM0jq/C2Wt+NxzBZVuk2nRb+0";
+        const USK = new Uint8Array(
+            olmlib.decodeBase64("lKWi3hJGUie5xxHgySoz8PHFnZv6wvNaud/p2shN9VU="),
+        );
+        const USPubKey = "CUpoiTtHiyXpUmd+3ohb7JVxAlUaOG1NYs9Jlx8soQU";
+        const SSK = new Uint8Array(
+            olmlib.decodeBase64("1R6JVlXX99UcfUZzKuCDGQgJTw8ur1/ofgPD8pp+96M="),
+        );
+        const SSPubKey = "0DfNsRDzEvkCLA0gD3m7VAGJ5VClhjEsewI35xq873Q";
+        const SSSSKey = new Uint8Array(
+            olmlib.decodeBase64(
+                "XrmITOOdBhw6yY5Bh7trb/bgp1FRdIGyCUxxMP873R0=",
+            ),
+        );
+
+        it("bootstraps when no storage or cross-signing keys locally", async function() {
+            const key = new Uint8Array(16);
+            for (let i = 0; i < 16; i++) key[i] = i;
+            const getKey = jest.fn(e => {
+                return [Object.keys(e.keys)[0], key];
             });
-            this.store.storeAccountDataEvents([
-                event,
-            ]);
-            this.emit("accountData", event);
-        };
 
-        await bob.bootstrapSecretStorage();
-
-        const crossSigning = bob._crypto._crossSigningInfo;
-        const secretStorage = bob._crypto._secretStorage;
-
-        expect(crossSigning.getId()).toBeTruthy();
-        expect(await crossSigning.isStoredInSecretStorage(secretStorage)).toBeTruthy();
-        expect(await secretStorage.hasKey()).toBeTruthy();
-    });
-
-    it("bootstraps when cross-signing keys in secret storage", async function() {
-        const decryption = new global.Olm.PkDecryption();
-        const storagePublicKey = decryption.generate_key();
-        const storagePrivateKey = decryption.get_private_key();
-
-        const bob = await makeTestClient(
-            {
-                userId: "@bob:example.com",
-                deviceId: "bob1",
-            },
-            {
-                cryptoCallbacks: {
-                    getSecretStorageKey: async request => {
-                        const defaultKeyId = await bob.getDefaultSecretStorageKeyId();
-                        expect(Object.keys(request.keys)).toEqual([defaultKeyId]);
-                        return [defaultKeyId, storagePrivateKey];
+            const bob = await makeTestClient(
+                {
+                    userId: "@bob:example.com",
+                    deviceId: "bob1",
+                },
+                {
+                    cryptoCallbacks: {
+                        getSecretStorageKey: getKey,
                     },
                 },
-            },
-        );
+            );
+            bob.uploadDeviceSigningKeys = async () => {};
+            bob.uploadKeySignatures = async () => {};
+            bob.setAccountData = async function(eventType, contents, callback) {
+                const event = new MatrixEvent({
+                    type: eventType,
+                    content: contents,
+                });
+                this.store.storeAccountDataEvents([
+                    event,
+                ]);
+                this.emit("accountData", event);
+            };
 
-        bob.uploadDeviceSigningKeys = async () => {};
-        bob.uploadKeySignatures = async () => {};
-        bob.setAccountData = async function(eventType, contents, callback) {
-            const event = new MatrixEvent({
-                type: eventType,
-                content: contents,
+            await bob.bootstrapCrossSigning({
+                authUploadDeviceSigningKeys: async func => await func({}),
+            });
+            await bob.bootstrapSecretStorage({
+                createSecretStorageKey,
             });
-            this.store.storeAccountDataEvents([
-                event,
-            ]);
-            this.emit("accountData", event);
-        };
-        bob._crypto.checkKeyBackup = async () => {};
 
-        const crossSigning = bob._crypto._crossSigningInfo;
-        const secretStorage = bob._crypto._secretStorage;
+            const crossSigning = bob.crypto.crossSigningInfo;
+            const secretStorage = bob.crypto.secretStorage;
 
-        // Set up cross-signing keys from scratch with specific storage key
-        await bob.bootstrapSecretStorage({
-            createSecretStorageKey: async () => ({ pubkey: storagePublicKey }),
+            expect(crossSigning.getId()).toBeTruthy();
+            expect(await crossSigning.isStoredInSecretStorage(secretStorage))
+                .toBeTruthy();
+            expect(await secretStorage.hasKey()).toBeTruthy();
         });
 
-        // Clear local cross-signing keys and read from secret storage
-        bob._crypto._deviceList.storeCrossSigningForUser(
-            "@bob:example.com",
-            crossSigning.toStorage(),
-        );
-        crossSigning.keys = {};
-        await bob.bootstrapSecretStorage();
+        it("bootstraps when cross-signing keys in secret storage", async function() {
+            const decryption = new global.Olm.PkDecryption();
+            const storagePublicKey = decryption.generate_key();
+            const storagePrivateKey = decryption.get_private_key();
 
-        expect(crossSigning.getId()).toBeTruthy();
-        expect(await crossSigning.isStoredInSecretStorage(secretStorage)).toBeTruthy();
-        expect(await secretStorage.hasKey()).toBeTruthy();
+            const bob = await makeTestClient(
+                {
+                    userId: "@bob:example.com",
+                    deviceId: "bob1",
+                },
+                {
+                    cryptoCallbacks: {
+                        getSecretStorageKey: async request => {
+                            const defaultKeyId = await bob.getDefaultSecretStorageKeyId();
+                            expect(Object.keys(request.keys)).toEqual([defaultKeyId]);
+                            return [defaultKeyId, storagePrivateKey];
+                        },
+                    },
+                },
+            );
+
+            bob.uploadDeviceSigningKeys = async () => {};
+            bob.uploadKeySignatures = async () => {};
+            bob.setAccountData = async function(eventType, contents, callback) {
+                const event = new MatrixEvent({
+                    type: eventType,
+                    content: contents,
+                });
+                this.store.storeAccountDataEvents([
+                    event,
+                ]);
+                this.emit("accountData", event);
+            };
+            bob.crypto.backupManager.checkKeyBackup = async () => {};
+
+            const crossSigning = bob.crypto.crossSigningInfo;
+            const secretStorage = bob.crypto.secretStorage;
+
+            // Set up cross-signing keys from scratch with specific storage key
+            await bob.bootstrapCrossSigning({
+                authUploadDeviceSigningKeys: async func => await func({}),
+            });
+            await bob.bootstrapSecretStorage({
+                createSecretStorageKey: async () => ({
+                    // `pubkey` not used anymore with symmetric 4S
+                    keyInfo: { pubkey: storagePublicKey },
+                    privateKey: storagePrivateKey,
+                }),
+            });
+
+            // Clear local cross-signing keys and read from secret storage
+            bob.crypto.deviceList.storeCrossSigningForUser(
+                "@bob:example.com",
+                crossSigning.toStorage(),
+            );
+            crossSigning.keys = {};
+            await bob.bootstrapCrossSigning({
+                authUploadDeviceSigningKeys: async func => await func({}),
+            });
+
+            expect(crossSigning.getId()).toBeTruthy();
+            expect(await crossSigning.isStoredInSecretStorage(secretStorage))
+                .toBeTruthy();
+            expect(await secretStorage.hasKey()).toBeTruthy();
+        });
+
+        it("adds passphrase checking if it's lacking", async function() {
+            let crossSigningKeys = {
+                master: XSK,
+                user_signing: USK,
+                self_signing: SSK,
+            };
+            const secretStorageKeys = {
+                key_id: SSSSKey,
+            };
+            const alice = await makeTestClient(
+                { userId: "@alice:example.com", deviceId: "Osborne2" },
+                {
+                    cryptoCallbacks: {
+                        getCrossSigningKey: t => crossSigningKeys[t],
+                        saveCrossSigningKeys: k => crossSigningKeys = k,
+                        getSecretStorageKey: ({ keys }, name) => {
+                            for (const keyId of Object.keys(keys)) {
+                                if (secretStorageKeys[keyId]) {
+                                    return [keyId, secretStorageKeys[keyId]];
+                                }
+                            }
+                        },
+                    },
+                },
+            );
+            alice.store.storeAccountDataEvents([
+                new MatrixEvent({
+                    type: "m.secret_storage.default_key",
+                    content: {
+                        key: "key_id",
+                    },
+                }),
+                new MatrixEvent({
+                    type: "m.secret_storage.key.key_id",
+                    content: {
+                        algorithm: "m.secret_storage.v1.aes-hmac-sha2",
+                        passphrase: {
+                            algorithm: "m.pbkdf2",
+                            iterations: 500000,
+                            salt: "GbkvwKHVMveo1zGVSb2GMMdCinG2npJK",
+                        },
+                    },
+                }),
+                // we never use these values, other than checking that they
+                // exist, so just use dummy values
+                new MatrixEvent({
+                    type: "m.cross_signing.master",
+                    content: {
+                        encrypted: {
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
+                        },
+                    },
+                }),
+                new MatrixEvent({
+                    type: "m.cross_signing.self_signing",
+                    content: {
+                        encrypted: {
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
+                        },
+                    },
+                }),
+                new MatrixEvent({
+                    type: "m.cross_signing.user_signing",
+                    content: {
+                        encrypted: {
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
+                        },
+                    },
+                }),
+            ]);
+            alice.crypto.deviceList.storeCrossSigningForUser("@alice:example.com", {
+                keys: {
+                    master: {
+                        user_id: "@alice:example.com",
+                        usage: ["master"],
+                        keys: {
+                            [`ed25519:${XSPubKey}`]: XSPubKey,
+                        },
+                    },
+                    self_signing: sign({
+                        user_id: "@alice:example.com",
+                        usage: ["self_signing"],
+                        keys: {
+                            [`ed25519:${SSPubKey}`]: SSPubKey,
+                        },
+                    }, XSK, "@alice:example.com"),
+                    user_signing: sign({
+                        user_id: "@alice:example.com",
+                        usage: ["user_signing"],
+                        keys: {
+                            [`ed25519:${USPubKey}`]: USPubKey,
+                        },
+                    }, XSK, "@alice:example.com"),
+                },
+            });
+            alice.getKeyBackupVersion = async () => {
+                return {
+                    version: "1",
+                    algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
+                    auth_data: sign({
+                        public_key: "pxEXhg+4vdMf/kFwP4bVawFWdb0EmytL3eFJx++zQ0A",
+                    }, XSK, "@alice:example.com"),
+                };
+            };
+            alice.setAccountData = async function(name, data) {
+                const event = new MatrixEvent({
+                    type: name,
+                    content: data,
+                });
+                alice.store.storeAccountDataEvents([event]);
+                this.emit("accountData", event);
+            };
+
+            await alice.bootstrapSecretStorage();
+
+            expect(alice.getAccountData("m.secret_storage.default_key").getContent())
+                .toEqual({ key: "key_id" });
+            const keyInfo = alice.getAccountData("m.secret_storage.key.key_id")
+                .getContent();
+            expect(keyInfo.algorithm)
+                .toEqual("m.secret_storage.v1.aes-hmac-sha2");
+            expect(keyInfo.passphrase).toEqual({
+                algorithm: "m.pbkdf2",
+                iterations: 500000,
+                salt: "GbkvwKHVMveo1zGVSb2GMMdCinG2npJK",
+            });
+            expect(keyInfo).toHaveProperty("iv");
+            expect(keyInfo).toHaveProperty("mac");
+            expect(alice.checkSecretStorageKey(secretStorageKeys.key_id, keyInfo))
+                .toBeTruthy();
+        });
+        it("fixes backup keys in the wrong format", async function() {
+            let crossSigningKeys = {
+                master: XSK,
+                user_signing: USK,
+                self_signing: SSK,
+            };
+            const secretStorageKeys = {
+                key_id: SSSSKey,
+            };
+            const alice = await makeTestClient(
+                { userId: "@alice:example.com", deviceId: "Osborne2" },
+                {
+                    cryptoCallbacks: {
+                        getCrossSigningKey: t => crossSigningKeys[t],
+                        saveCrossSigningKeys: k => crossSigningKeys = k,
+                        getSecretStorageKey: ({ keys }, name) => {
+                            for (const keyId of Object.keys(keys)) {
+                                if (secretStorageKeys[keyId]) {
+                                    return [keyId, secretStorageKeys[keyId]];
+                                }
+                            }
+                        },
+                    },
+                },
+            );
+            alice.store.storeAccountDataEvents([
+                new MatrixEvent({
+                    type: "m.secret_storage.default_key",
+                    content: {
+                        key: "key_id",
+                    },
+                }),
+                new MatrixEvent({
+                    type: "m.secret_storage.key.key_id",
+                    content: {
+                        algorithm: "m.secret_storage.v1.aes-hmac-sha2",
+                        passphrase: {
+                            algorithm: "m.pbkdf2",
+                            iterations: 500000,
+                            salt: "GbkvwKHVMveo1zGVSb2GMMdCinG2npJK",
+                        },
+                    },
+                }),
+                new MatrixEvent({
+                    type: "m.cross_signing.master",
+                    content: {
+                        encrypted: {
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
+                        },
+                    },
+                }),
+                new MatrixEvent({
+                    type: "m.cross_signing.self_signing",
+                    content: {
+                        encrypted: {
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
+                        },
+                    },
+                }),
+                new MatrixEvent({
+                    type: "m.cross_signing.user_signing",
+                    content: {
+                        encrypted: {
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
+                        },
+                    },
+                }),
+                new MatrixEvent({
+                    type: "m.megolm_backup.v1",
+                    content: {
+                        encrypted: {
+                            key_id: await encryptAES(
+                                "123,45,6,7,89,1,234,56,78,90,12,34,5,67,8,90",
+                                secretStorageKeys.key_id, "m.megolm_backup.v1",
+                            ),
+                        },
+                    },
+                }),
+            ]);
+            alice.crypto.deviceList.storeCrossSigningForUser("@alice:example.com", {
+                keys: {
+                    master: {
+                        user_id: "@alice:example.com",
+                        usage: ["master"],
+                        keys: {
+                            [`ed25519:${XSPubKey}`]: XSPubKey,
+                        },
+                    },
+                    self_signing: sign({
+                        user_id: "@alice:example.com",
+                        usage: ["self_signing"],
+                        keys: {
+                            [`ed25519:${SSPubKey}`]: SSPubKey,
+                        },
+                    }, XSK, "@alice:example.com"),
+                    user_signing: sign({
+                        user_id: "@alice:example.com",
+                        usage: ["user_signing"],
+                        keys: {
+                            [`ed25519:${USPubKey}`]: USPubKey,
+                        },
+                    }, XSK, "@alice:example.com"),
+                },
+            });
+            alice.getKeyBackupVersion = async () => {
+                return {
+                    version: "1",
+                    algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
+                    auth_data: sign({
+                        public_key: "pxEXhg+4vdMf/kFwP4bVawFWdb0EmytL3eFJx++zQ0A",
+                    }, XSK, "@alice:example.com"),
+                };
+            };
+            alice.setAccountData = async function(name, data) {
+                const event = new MatrixEvent({
+                    type: name,
+                    content: data,
+                });
+                alice.store.storeAccountDataEvents([event]);
+                this.emit("accountData", event);
+            };
+
+            await alice.bootstrapSecretStorage();
+
+            const backupKey = alice.getAccountData("m.megolm_backup.v1")
+                .getContent();
+            expect(backupKey.encrypted).toHaveProperty("key_id");
+            expect(await alice.getSecret("m.megolm_backup.v1"))
+                .toEqual("ey0GB1kB6jhOWgwiBUMIWg==");
+        });
     });
 });

spec/unit/crypto/verification/InRoomChannel.spec.js

@@ -13,9 +13,9 @@ 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 {InRoomChannel} from "../../../../src/crypto/verification/request/InRoomChannel";
+import { InRoomChannel } from "../../../../src/crypto/verification/request/InRoomChannel";
     "../../../../src/crypto/verification/request/ToDeviceChannel";
-import {MatrixEvent} from "../../../../src/models/event";
+import { MatrixEvent } from "../../../../src/models/event";
 
 describe("InRoomChannel tests", function() {
     const ALICE = "@alice:hs.tld";

spec/unit/crypto/verification/qr_code.spec.js

@@ -15,7 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import "../../../olm-loader";
-import {logger} from "../../../../src/logger";
+import { logger } from "../../../../src/logger";
 
 const Olm = global.Olm;
 

spec/unit/crypto/verification/request.spec.js

@@ -15,10 +15,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import "../../../olm-loader";
-import {verificationMethods} from "../../../../src/crypto";
-import {logger} from "../../../../src/logger";
-import {SAS} from "../../../../src/crypto/verification/SAS";
-import {makeTestClients, setupWebcrypto, teardownWebcrypto} from './util';
+import { verificationMethods } from "../../../../src/crypto";
+import { logger } from "../../../../src/logger";
+import { SAS } from "../../../../src/crypto/verification/SAS";
+import { makeTestClients, setupWebcrypto, teardownWebcrypto } from './util';
 
 const Olm = global.Olm;
 
@@ -42,14 +42,14 @@ describe("verification request integration tests with crypto layer", function()
     it("should request and accept a verification", async function() {
         const [alice, bob] = await makeTestClients(
             [
-                {userId: "@alice:example.com", deviceId: "Osborne2"},
-                {userId: "@bob:example.com", deviceId: "Dynabook"},
+                { userId: "@alice:example.com", deviceId: "Osborne2" },
+                { userId: "@bob:example.com", deviceId: "Dynabook" },
             ],
             {
                 verificationMethods: [verificationMethods.SAS],
             },
         );
-        alice.client._crypto._deviceList.getRawStoredDevicesForUser = function() {
+        alice.client.crypto.deviceList.getRawStoredDevicesForUser = function() {
             return {
                 Dynabook: {
                     keys: {
@@ -69,7 +69,7 @@ describe("verification request integration tests with crypto layer", function()
             bobVerifier.verify();
 
             // XXX: Private function access (but it's a test, so we're okay)
-            bobVerifier._endTimer();
+            bobVerifier.endTimer();
         });
         const aliceRequest = await alice.client.requestVerification("@bob:example.com");
         await aliceRequest.waitFor(r => r.started);
@@ -77,6 +77,6 @@ describe("verification request integration tests with crypto layer", function()
         expect(aliceVerifier).toBeInstanceOf(SAS);
 
         // XXX: Private function access (but it's a test, so we're okay)
-        aliceVerifier._endTimer();
+        aliceVerifier.endTimer();
     });
 });

spec/unit/crypto/verification/sas.spec.js

@@ -15,13 +15,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import "../../../olm-loader";
-import {makeTestClients, setupWebcrypto, teardownWebcrypto} from './util';
-import {MatrixEvent} from "../../../../src/models/event";
-import {SAS} from "../../../../src/crypto/verification/SAS";
-import {DeviceInfo} from "../../../../src/crypto/deviceinfo";
-import {verificationMethods} from "../../../../src/crypto";
+import { makeTestClients, setupWebcrypto, teardownWebcrypto } from './util';
+import { MatrixEvent } from "../../../../src/models/event";
+import { SAS } from "../../../../src/crypto/verification/SAS";
+import { DeviceInfo } from "../../../../src/crypto/deviceinfo";
+import { verificationMethods } from "../../../../src/crypto";
 import * as olmlib from "../../../../src/crypto/olmlib";
-import {logger} from "../../../../src/logger";
+import { logger } from "../../../../src/logger";
+import { resetCrossSigningKeys } from "../crypto-utils";
 
 const Olm = global.Olm;
 
@@ -44,7 +45,16 @@ describe("SAS verification", function() {
     });
 
     it("should error on an unexpected event", async function() {
-        const sas = new SAS({}, "@alice:example.com", "ABCDEFG");
+        //channel, baseApis, userId, deviceId, startEvent, request
+        const request = {
+            onVerifierCancelled: function() {},
+        };
+        const channel = {
+            send: function() {
+                return Promise.resolve();
+            },
+        };
+        const sas = new SAS(channel, {}, "@alice:example.com", "ABCDEFG", null, request);
         sas.handleEvent(new MatrixEvent({
             sender: "@alice:example.com",
             type: "es.inquisition",
@@ -69,16 +79,16 @@ describe("SAS verification", function() {
         beforeEach(async () => {
             [alice, bob] = await makeTestClients(
                 [
-                    {userId: "@alice:example.com", deviceId: "Osborne2"},
-                    {userId: "@bob:example.com", deviceId: "Dynabook"},
+                    { userId: "@alice:example.com", deviceId: "Osborne2" },
+                    { userId: "@bob:example.com", deviceId: "Dynabook" },
                 ],
                 {
                     verificationMethods: [verificationMethods.SAS],
                 },
             );
 
-            const aliceDevice = alice.client._crypto._olmDevice;
-            const bobDevice = bob.client._crypto._olmDevice;
+            const aliceDevice = alice.client.crypto.olmDevice;
+            const bobDevice = bob.client.crypto.olmDevice;
 
             ALICE_DEVICES = {
                 Osborne2: {
@@ -104,14 +114,14 @@ describe("SAS verification", function() {
                 },
             };
 
-            alice.client._crypto._deviceList.storeDevicesForUser(
+            alice.client.crypto.deviceList.storeDevicesForUser(
                 "@bob:example.com", BOB_DEVICES,
             );
             alice.client.downloadKeys = () => {
                 return Promise.resolve();
             };
 
-            bob.client._crypto._deviceList.storeDevicesForUser(
+            bob.client.crypto.deviceList.storeDevicesForUser(
                 "@alice:example.com", ALICE_DEVICES,
             );
             bob.client.downloadKeys = () => {
@@ -172,11 +182,14 @@ describe("SAS verification", function() {
 
         it("should verify a key", async () => {
             let macMethod;
+            let keyAgreement;
             const origSendToDevice = bob.client.sendToDevice.bind(bob.client);
             bob.client.sendToDevice = function(type, map) {
                 if (type === "m.key.verification.accept") {
                     macMethod = map[alice.client.getUserId()][alice.client.deviceId]
                         .message_authentication_code;
+                    keyAgreement = map[alice.client.getUserId()][alice.client.deviceId]
+                        .key_agreement_protocol;
                 }
                 return origSendToDevice(type, map);
             };
@@ -203,6 +216,7 @@ describe("SAS verification", function() {
 
             // make sure that it uses the preferred method
             expect(macMethod).toBe("hkdf-hmac-sha256");
+            expect(keyAgreement).toBe("curve25519-hkdf-sha256");
 
             // make sure Alice and Bob verified each other
             const bobDevice
@@ -275,16 +289,16 @@ describe("SAS verification", function() {
             );
             alice.httpBackend.when('POST', '/keys/signatures/upload').respond(200, {});
             alice.httpBackend.flush(undefined, 2);
-            await alice.client.resetCrossSigningKeys();
+            await resetCrossSigningKeys(alice.client);
             bob.httpBackend.when('POST', '/keys/device_signing/upload').respond(200, {});
             bob.httpBackend.when('POST', '/keys/signatures/upload').respond(200, {});
             bob.httpBackend.flush(undefined, 2);
 
-            await bob.client.resetCrossSigningKeys();
+            await resetCrossSigningKeys(bob.client);
 
-            bob.client._crypto._deviceList.storeCrossSigningForUser(
+            bob.client.crypto.deviceList.storeCrossSigningForUser(
                 "@alice:example.com", {
-                    keys: alice.client._crypto._crossSigningInfo.keys,
+                    keys: alice.client.crypto.crossSigningInfo.keys,
                 },
             );
 
@@ -322,8 +336,8 @@ describe("SAS verification", function() {
     it("should send a cancellation message on error", async function() {
         const [alice, bob] = await makeTestClients(
             [
-                {userId: "@alice:example.com", deviceId: "Osborne2"},
-                {userId: "@bob:example.com", deviceId: "Dynabook"},
+                { userId: "@alice:example.com", deviceId: "Osborne2" },
+                { userId: "@bob:example.com", deviceId: "Dynabook" },
             ],
             {
                 verificationMethods: [verificationMethods.SAS],
@@ -376,8 +390,8 @@ describe("SAS verification", function() {
         beforeEach(async function() {
             [alice, bob] = await makeTestClients(
                 [
-                    {userId: "@alice:example.com", deviceId: "Osborne2"},
-                    {userId: "@bob:example.com", deviceId: "Dynabook"},
+                    { userId: "@alice:example.com", deviceId: "Osborne2" },
+                    { userId: "@bob:example.com", deviceId: "Dynabook" },
                 ],
                 {
                     verificationMethods: [verificationMethods.SAS],

spec/unit/crypto/verification/secret_request.spec.js

@@ -14,10 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {VerificationBase} from '../../../../src/crypto/verification/Base';
-import {CrossSigningInfo} from '../../../../src/crypto/CrossSigning';
-import {encodeBase64} from "../../../../src/crypto/olmlib";
-import {setupWebcrypto, teardownWebcrypto} from './util';
+import { VerificationBase } from '../../../../src/crypto/verification/Base';
+import { CrossSigningInfo } from '../../../../src/crypto/CrossSigning';
+import { encodeBase64 } from "../../../../src/crypto/olmlib";
+import { setupWebcrypto, teardownWebcrypto } from './util';
 
 jest.useFakeTimers();
 
@@ -48,28 +48,37 @@ describe("self-verifications", () => {
             storeCrossSigningKeyCache: jest.fn(),
         };
 
-        const _crossSigningInfo = new CrossSigningInfo(
+        const crossSigningInfo = new CrossSigningInfo(
             userId,
             {},
             cacheCallbacks,
         );
-        _crossSigningInfo.keys = {
+        crossSigningInfo.keys = {
+            master: { keys: { X: testKeyPub } },
             self_signing: { keys: { X: testKeyPub } },
             user_signing: { keys: { X: testKeyPub } },
         };
 
-        const _secretStorage = {
+        const secretStorage = {
             request: jest.fn().mockReturnValue({
                 promise: Promise.resolve(encodeBase64(testKey)),
             }),
         };
 
+        const storeSessionBackupPrivateKey = jest.fn();
+        const restoreKeyBackupWithCache = jest.fn(() => Promise.resolve());
+
         const client = {
-            _crypto: {
-                _crossSigningInfo,
-                _secretStorage,
+            crypto: {
+                crossSigningInfo,
+                secretStorage,
+                storeSessionBackupPrivateKey,
+                getSessionBackupPrivateKey: () => null,
             },
+            requestSecret: secretStorage.request.bind(secretStorage),
             getUserId: () => userId,
+            getKeyBackupVersion: () => Promise.resolve({}),
+            restoreKeyBackupWithCache,
         };
 
         const request = {
@@ -84,19 +93,24 @@ describe("self-verifications", () => {
             undefined, // startEvent
             request,
         );
-        verification._resolve = () => undefined;
+        verification.resolve = () => undefined;
 
         const result = await verification.done();
 
-        /* We should request, and store, two keys */
-        expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls.length).toBe(2);
-        expect(_secretStorage.request.mock.calls.length).toBe(2);
+        /* We should request, and store, 3 cross signing keys and the key backup key */
+        expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls.length).toBe(3);
+        expect(secretStorage.request.mock.calls.length).toBe(4);
 
         expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls[0][1])
           .toEqual(testKey);
         expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls[1][1])
           .toEqual(testKey);
 
+        expect(storeSessionBackupPrivateKey.mock.calls[0][0])
+          .toEqual(testKey);
+
+        expect(restoreKeyBackupWithCache).toHaveBeenCalled();
+
         expect(result).toBeInstanceOf(Array);
         expect(result[0][0]).toBe(testKeyPub);
         expect(result[1][0]).toBe(testKeyPub);

spec/unit/crypto/verification/util.js

@@ -15,27 +15,28 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {TestClient} from '../../../TestClient';
-import {MatrixEvent} from "../../../../src/models/event";
+import { TestClient } from '../../../TestClient';
+import { MatrixEvent } from "../../../../src/models/event";
 import nodeCrypto from "crypto";
+import { logger } from '../../../../src/logger';
 
 export async function makeTestClients(userInfos, options) {
     const clients = [];
     const clientMap = {};
     const sendToDevice = function(type, map) {
-        // console.log(this.getUserId(), "sends", type, map);
+        // logger.log(this.getUserId(), "sends", type, map);
         for (const [userId, devMap] of Object.entries(map)) {
             if (userId in clientMap) {
                 for (const [deviceId, msg] of Object.entries(devMap)) {
                     if (deviceId in clientMap[userId]) {
                         const event = new MatrixEvent({
-                            sender: this.getUserId(), // eslint-disable-line babel/no-invalid-this
+                            sender: this.getUserId(), // eslint-disable-line @babel/no-invalid-this
                             type: type,
                             content: msg,
                         });
                         const client = clientMap[userId][deviceId];
                         const decryptionPromise = event.isEncrypted() ?
-                            event.attemptDecryption(client._crypto) :
+                            event.attemptDecryption(client.crypto) :
                             Promise.resolve();
 
                         decryptionPromise.then(
@@ -48,9 +49,9 @@ export async function makeTestClients(userInfos, options) {
     };
     const sendEvent = function(room, type, content) {
         // make up a unique ID as the event ID
-        const eventId = "$" + this.makeTxnId(); // eslint-disable-line babel/no-invalid-this
+        const eventId = "$" + this.makeTxnId(); // eslint-disable-line @babel/no-invalid-this
         const rawEvent = {
-            sender: this.getUserId(), // eslint-disable-line babel/no-invalid-this
+            sender: this.getUserId(), // eslint-disable-line @babel/no-invalid-this
             type: type,
             content: content,
             room_id: room,
@@ -60,14 +61,14 @@ export async function makeTestClients(userInfos, options) {
         const event = new MatrixEvent(rawEvent);
         const remoteEcho = new MatrixEvent(Object.assign({}, rawEvent, {
             unsigned: {
-                transaction_id: this.makeTxnId(), // eslint-disable-line babel/no-invalid-this
+                transaction_id: this.makeTxnId(), // eslint-disable-line @babel/no-invalid-this
             },
         }));
 
         setImmediate(() => {
             for (const tc of clients) {
-                if (tc.client === this) { // eslint-disable-line babel/no-invalid-this
-                    console.log("sending remote echo!!");
+                if (tc.client === this) { // eslint-disable-line @babel/no-invalid-this
+                    logger.log("sending remote echo!!");
                     tc.client.emit("Room.timeline", remoteEcho);
                 } else {
                     tc.client.emit("Room.timeline", event);
@@ -75,7 +76,7 @@ export async function makeTestClients(userInfos, options) {
             }
         });
 
-        return Promise.resolve({event_id: eventId});
+        return Promise.resolve({ event_id: eventId });
     };
 
     for (const userInfo of userInfos) {

spec/unit/crypto/verification/verification_request.spec.js

@@ -13,13 +13,13 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-import {VerificationRequest, READY_TYPE, START_TYPE, DONE_TYPE} from
+import { VerificationRequest, READY_TYPE, START_TYPE, DONE_TYPE } from
     "../../../../src/crypto/verification/request/VerificationRequest";
-import {InRoomChannel} from "../../../../src/crypto/verification/request/InRoomChannel";
-import {ToDeviceChannel} from
+import { InRoomChannel } from "../../../../src/crypto/verification/request/InRoomChannel";
+import { ToDeviceChannel } from
     "../../../../src/crypto/verification/request/ToDeviceChannel";
-import {MatrixEvent} from "../../../../src/models/event";
-import {setupWebcrypto, teardownWebcrypto} from "./util";
+import { MatrixEvent } from "../../../../src/models/event";
+import { setupWebcrypto, teardownWebcrypto } from "./util";
 
 function makeMockClient(userId, deviceId) {
     let counter = 1;
@@ -40,7 +40,7 @@ function makeMockClient(userId, deviceId) {
                 content,
                 origin_server_ts: Date.now(),
             }));
-            return Promise.resolve({event_id: eventId});
+            return Promise.resolve({ event_id: eventId });
         },
 
         sendToDevice(type, msgMap) {
@@ -48,7 +48,7 @@ function makeMockClient(userId, deviceId) {
                 const deviceMap = msgMap[userId];
                 for (const deviceId of Object.keys(deviceMap)) {
                     const content = deviceMap[deviceId];
-                    const event = new MatrixEvent({content, type});
+                    const event = new MatrixEvent({ content, type });
                     deviceEvents[userId] = deviceEvents[userId] || {};
                     deviceEvents[userId][deviceId] = deviceEvents[userId][deviceId] || [];
                     deviceEvents[userId][deviceId].push(event);
@@ -90,7 +90,7 @@ class MockVerifier {
         if (this._startEvent) {
             await this._channel.send(DONE_TYPE, {});
         } else {
-            await this._channel.send(START_TYPE, {method: MOCK_METHOD});
+            await this._channel.send(START_TYPE, { method: MOCK_METHOD });
         }
     }
 
@@ -119,6 +119,8 @@ async function distributeEvent(ownRequest, theirRequest, event) {
     await theirRequest.channel.handleEvent(event, theirRequest, true);
 }
 
+jest.useFakeTimers();
+
 describe("verification request unit tests", function() {
     beforeAll(function() {
         setupWebcrypto();
@@ -224,7 +226,7 @@ describe("verification request unit tests", function() {
             new ToDeviceChannel(bob1, bob1.getUserId(), ["device1", "device2"],
                 ToDeviceChannel.makeTransactionId(), "device2"),
             new Map([[MOCK_METHOD, MockVerifier]]), bob1);
-        const to = {userId: "@bob:matrix.tld", deviceId: "device2"};
+        const to = { userId: "@bob:matrix.tld", deviceId: "device2" };
         const verifier = bob1Request.beginKeyVerification(MOCK_METHOD, to);
         expect(verifier).toBeInstanceOf(MockVerifier);
         await verifier.start();
@@ -246,4 +248,38 @@ describe("verification request unit tests", function() {
         expect(bob1Request.done).toBe(true);
         expect(bob2Request.done).toBe(true);
     });
+
+    it("request times out after 10 minutes", async function() {
+        const alice = makeMockClient("@alice:matrix.tld", "device1");
+        const bob = makeMockClient("@bob:matrix.tld", "device1");
+        const aliceRequest = new VerificationRequest(
+            new InRoomChannel(alice, "!room", bob.getUserId()), new Map(), alice);
+        await aliceRequest.sendRequest();
+        const [requestEvent] = alice.popEvents();
+        await aliceRequest.channel.handleEvent(requestEvent, aliceRequest, true,
+            true, true);
+
+        expect(aliceRequest.cancelled).toBe(false);
+        expect(aliceRequest._cancellingUserId).toBe(undefined);
+        jest.advanceTimersByTime(10 * 60 * 1000);
+        expect(aliceRequest._cancellingUserId).toBe(alice.getUserId());
+    });
+
+    it("request times out 2 minutes after receipt", async function() {
+        const alice = makeMockClient("@alice:matrix.tld", "device1");
+        const bob = makeMockClient("@bob:matrix.tld", "device1");
+        const aliceRequest = new VerificationRequest(
+            new InRoomChannel(alice, "!room", bob.getUserId()), new Map(), alice);
+        await aliceRequest.sendRequest();
+        const [requestEvent] = alice.popEvents();
+        const bobRequest = new VerificationRequest(
+            new InRoomChannel(bob, "!room"), new Map(), bob);
+
+        await bobRequest.channel.handleEvent(requestEvent, bobRequest, true);
+
+        expect(bobRequest.cancelled).toBe(false);
+        expect(bobRequest._cancellingUserId).toBe(undefined);
+        jest.advanceTimersByTime(2 * 60 * 1000);
+        expect(bobRequest._cancellingUserId).toBe(bob.getUserId());
+    });
 });

spec/unit/event-timeline.spec.js

@@ -1,10 +1,10 @@
 import * as utils from "../test-utils";
-import {EventTimeline} from "../../src/models/event-timeline";
-import {RoomState} from "../../src/models/room-state";
+import { EventTimeline } from "../../src/models/event-timeline";
+import { RoomState } from "../../src/models/room-state";
 
 function mockRoomStates(timeline) {
-    timeline._startState = utils.mock(RoomState, "startState");
-    timeline._endState = utils.mock(RoomState, "endState");
+    timeline.startState = utils.mock(RoomState, "startState");
+    timeline.endState = utils.mock(RoomState, "endState");
 }
 
 describe("EventTimeline", function() {
@@ -15,7 +15,7 @@ describe("EventTimeline", function() {
 
     beforeEach(function() {
         // XXX: this is a horrid hack; should use sinon or something instead to mock
-        const timelineSet = { room: { roomId: roomId }};
+        const timelineSet = { room: { roomId: roomId } };
         timelineSet.room.getUnfilteredTimelineSet = function() {
             return timelineSet;
         };
@@ -48,10 +48,10 @@ describe("EventTimeline", function() {
                 }),
             ];
             timeline.initialiseState(events);
-            expect(timeline._startState.setStateEvents).toHaveBeenCalledWith(
+            expect(timeline.startState.setStateEvents).toHaveBeenCalledWith(
                 events,
             );
-            expect(timeline._endState.setStateEvents).toHaveBeenCalledWith(
+            expect(timeline.endState.setStateEvents).toHaveBeenCalledWith(
                 events,
             );
         });
@@ -94,7 +94,6 @@ describe("EventTimeline", function() {
         });
     });
 
-
     describe("neighbouringTimelines", function() {
         it("neighbouring timelines should start null", function() {
             expect(timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS)).toBe(null);
@@ -102,8 +101,8 @@ describe("EventTimeline", function() {
         });
 
         it("setNeighbouringTimeline should set neighbour", function() {
-            const prev = {a: "a"};
-            const next = {b: "b"};
+            const prev = { a: "a" };
+            const next = { b: "b" };
             timeline.setNeighbouringTimeline(prev, EventTimeline.BACKWARDS);
             timeline.setNeighbouringTimeline(next, EventTimeline.FORWARDS);
             expect(timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS)).toBe(prev);
@@ -111,8 +110,8 @@ describe("EventTimeline", function() {
         });
 
         it("setNeighbouringTimeline should throw if called twice", function() {
-            const prev = {a: "a"};
-            const next = {b: "b"};
+            const prev = { a: "a" };
+            const next = { b: "b" };
             expect(function() {
                 timeline.setNeighbouringTimeline(prev, EventTimeline.BACKWARDS);
             }).not.toThrow();
@@ -278,7 +277,6 @@ describe("EventTimeline", function() {
                 not.toHaveBeenCalled();
         });
 
-
         it("should call setStateEvents on the right RoomState with the right " +
            "forwardLooking value for old events", function() {
             const events = [

spec/unit/event.spec.js

@@ -15,8 +15,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {logger} from "../../src/logger";
-import {MatrixEvent} from "../../src/models/event";
+import { logger } from "../../src/logger";
+import { MatrixEvent } from "../../src/models/event";
 
 describe("MatrixEvent", () => {
     describe(".attemptDecryption", () => {

spec/unit/filter-component.spec.js

@@ -0,0 +1,34 @@
+import { FilterComponent } from "../../src/filter-component";
+import { mkEvent } from '../test-utils';
+
+describe("Filter Component", function() {
+    describe("types", function() {
+        it("should filter out events with other types", function() {
+            const filter = new FilterComponent({ types: ['m.room.message'] });
+            const event = mkEvent({
+                type: 'm.room.member',
+                content: { },
+                room: 'roomId',
+                event: true,
+            });
+
+            const checkResult = filter.check(event);
+
+            expect(checkResult).toBe(false);
+        });
+
+        it("should validate events with the same type", function() {
+            const filter = new FilterComponent({ types: ['m.room.message'] });
+            const event = mkEvent({
+                type: 'm.room.message',
+                content: { },
+                room: 'roomId',
+                event: true,
+            });
+
+            const checkResult = filter.check(event);
+
+            expect(checkResult).toBe(true);
+        });
+    });
+});

spec/unit/filter.spec.js

@@ -1,4 +1,4 @@
-import {Filter} from "../../src/filter";
+import { Filter } from "../../src/filter";
 
 describe("Filter", function() {
     const filterId = "f1lt3ring15g00d4ursoul";

spec/unit/interactive-auth.spec.js

@@ -15,9 +15,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {logger} from "../../src/logger";
-import {InteractiveAuth} from "../../src/interactive-auth";
-import {MatrixError} from "../../src/http-api";
+import { logger } from "../../src/logger";
+import { InteractiveAuth } from "../../src/interactive-auth";
+import { MatrixError } from "../../src/http-api";
 
 // Trivial client object to test interactive auth
 // (we do not need TestClient here)
@@ -63,7 +63,7 @@ describe("InteractiveAuth", function() {
         });
 
         // .. which should trigger a call here
-        const requestRes = {"a": "b"};
+        const requestRes = { "a": "b" };
         doRequest.mockImplementation(function(authData) {
             logger.log('cccc');
             expect(authData).toEqual({
@@ -97,7 +97,7 @@ describe("InteractiveAuth", function() {
         // first we expect a call to doRequest
         doRequest.mockImplementation(function(authData) {
             logger.log("request1", authData);
-            expect(authData).toEqual({});
+            expect(authData).toEqual(null); // first request should be null
             const err = new MatrixError({
                 session: "sessionId",
                 flows: [
@@ -112,7 +112,7 @@ describe("InteractiveAuth", function() {
         });
 
         // .. which should be followed by a call to stateUpdated
-        const requestRes = {"a": "b"};
+        const requestRes = { "a": "b" };
         stateUpdated.mockImplementation(function(stage) {
             expect(stage).toEqual("logintype");
             expect(ia.getSessionId()).toEqual("sessionId");
@@ -143,4 +143,33 @@ describe("InteractiveAuth", function() {
             expect(stateUpdated).toBeCalledTimes(1);
         });
     });
+
+    it("should start an auth stage and reject if no auth flow", function() {
+        const doRequest = jest.fn();
+        const stateUpdated = jest.fn();
+
+        const ia = new InteractiveAuth({
+            matrixClient: new FakeClient(),
+            doRequest: doRequest,
+            stateUpdated: stateUpdated,
+        });
+
+        doRequest.mockImplementation(function(authData) {
+            logger.log("request1", authData);
+            expect(authData).toEqual(null); // first request should be null
+            const err = new MatrixError({
+                session: "sessionId",
+                flows: [],
+                params: {
+                    "logintype": { param: "aa" },
+                },
+            });
+            err.httpStatus = 401;
+            throw err;
+        });
+
+        return ia.attemptAuth().catch(function(error) {
+            expect(error.message).toBe('No appropriate authentication flow found');
+        });
+    });
 });

spec/unit/login.spec.js

@@ -1,4 +1,4 @@
-import {TestClient} from '../TestClient';
+import { TestClient } from '../TestClient';
 
 describe('Login request', function() {
     let client;

spec/unit/matrix-client.spec.js

@@ -1,6 +1,18 @@
-import {logger} from "../../src/logger";
-import {MatrixClient} from "../../src/client";
-import {Filter} from "../../src/filter";
+import { logger } from "../../src/logger";
+import { MatrixClient } from "../../src/client";
+import { Filter } from "../../src/filter";
+import { DEFAULT_TREE_POWER_LEVELS_TEMPLATE } from "../../src/models/MSC3089TreeSpace";
+import {
+    EventType,
+    RoomCreateTypeField,
+    RoomType,
+    UNSTABLE_MSC3088_ENABLED,
+    UNSTABLE_MSC3088_PURPOSE,
+    UNSTABLE_MSC3089_TREE_SUBTYPE,
+} from "../../src/@types/event";
+import { MEGOLM_ALGORITHM } from "../../src/crypto/olmlib";
+import { MatrixEvent } from "../../src/models/event";
+import { Preset } from "../../src/@types/partials";
 
 jest.useFakeTimers();
 
@@ -144,12 +156,12 @@ describe("MatrixClient", function() {
             scheduler: scheduler,
             userId: userId,
         });
-        // FIXME: We shouldn't be yanking _http like this.
-        client._http = [
+        // FIXME: We shouldn't be yanking http like this.
+        client.http = [
             "authedRequest", "getContentUri", "request", "uploadContent",
         ].reduce((r, k) => { r[k] = jest.fn(); return r; }, {});
-        client._http.authedRequest.mockImplementation(httpReq);
-        client._http.request.mockImplementation(httpReq);
+        client.http.authedRequest.mockImplementation(httpReq);
+        client.http.request.mockImplementation(httpReq);
 
         // set reasonable working defaults
         acceptKeepalives = true;
@@ -166,11 +178,191 @@ describe("MatrixClient", function() {
         // means they may call /events and then fail an expect() which will fail
         // a DIFFERENT test (pollution between tests!) - we return unresolved
         // promises to stop the client from continuing to run.
-        client._http.authedRequest.mockImplementation(function() {
+        client.http.authedRequest.mockImplementation(function() {
             return new Promise(() => {});
         });
     });
 
+    it("should create (unstable) file trees", async () => {
+        const userId = "@test:example.org";
+        const roomId = "!room:example.org";
+        const roomName = "Test Tree";
+        const mockRoom = {};
+        const fn = jest.fn().mockImplementation((opts) => {
+            expect(opts).toMatchObject({
+                name: roomName,
+                preset: Preset.PrivateChat,
+                power_level_content_override: {
+                    ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
+                    users: {
+                        [userId]: 100,
+                    },
+                },
+                creation_content: {
+                    [RoomCreateTypeField]: RoomType.Space,
+                },
+                initial_state: [
+                    {
+                        // We use `unstable` to ensure that the code is actually using the right identifier
+                        type: UNSTABLE_MSC3088_PURPOSE.unstable,
+                        state_key: UNSTABLE_MSC3089_TREE_SUBTYPE.unstable,
+                        content: {
+                            [UNSTABLE_MSC3088_ENABLED.unstable]: true,
+                        },
+                    },
+                    {
+                        type: EventType.RoomEncryption,
+                        state_key: "",
+                        content: {
+                            algorithm: MEGOLM_ALGORITHM,
+                        },
+                    },
+                ],
+            });
+            return { room_id: roomId };
+        });
+        client.getUserId = () => userId;
+        client.createRoom = fn;
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return mockRoom;
+        };
+        const tree = await client.unstableCreateFileTree(roomName);
+        expect(tree).toBeDefined();
+        expect(tree.roomId).toEqual(roomId);
+        expect(tree.room).toBe(mockRoom);
+        expect(fn.mock.calls.length).toBe(1);
+    });
+
+    it("should get (unstable) file trees with valid state", async () => {
+        const roomId = "!room:example.org";
+        const mockRoom = {
+            getMyMembership: () => "join",
+            currentState: {
+                getStateEvents: (eventType, stateKey) => {
+                    if (eventType === EventType.RoomCreate) {
+                        expect(stateKey).toEqual("");
+                        return new MatrixEvent({
+                            content: {
+                                [RoomCreateTypeField]: RoomType.Space,
+                            },
+                        });
+                    } else if (eventType === UNSTABLE_MSC3088_PURPOSE.unstable) {
+                        // We use `unstable` to ensure that the code is actually using the right identifier
+                        expect(stateKey).toEqual(UNSTABLE_MSC3089_TREE_SUBTYPE.unstable);
+                        return new MatrixEvent({
+                            content: {
+                                [UNSTABLE_MSC3088_ENABLED.unstable]: true,
+                            },
+                        });
+                    } else {
+                        throw new Error("Unexpected event type or state key");
+                    }
+                },
+            },
+        };
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return mockRoom;
+        };
+        const tree = client.unstableGetFileTreeSpace(roomId);
+        expect(tree).toBeDefined();
+        expect(tree.roomId).toEqual(roomId);
+        expect(tree.room).toBe(mockRoom);
+    });
+
+    it("should not get (unstable) file trees if not joined", async () => {
+        const roomId = "!room:example.org";
+        const mockRoom = {
+            getMyMembership: () => "leave", // "not join"
+        };
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return mockRoom;
+        };
+        const tree = client.unstableGetFileTreeSpace(roomId);
+        expect(tree).toBeFalsy();
+    });
+
+    it("should not get (unstable) file trees for unknown rooms", async () => {
+        const roomId = "!room:example.org";
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return null; // imply unknown
+        };
+        const tree = client.unstableGetFileTreeSpace(roomId);
+        expect(tree).toBeFalsy();
+    });
+
+    it("should not get (unstable) file trees with invalid create contents", async () => {
+        const roomId = "!room:example.org";
+        const mockRoom = {
+            getMyMembership: () => "join",
+            currentState: {
+                getStateEvents: (eventType, stateKey) => {
+                    if (eventType === EventType.RoomCreate) {
+                        expect(stateKey).toEqual("");
+                        return new MatrixEvent({
+                            content: {
+                                [RoomCreateTypeField]: "org.example.not_space",
+                            },
+                        });
+                    } else if (eventType === UNSTABLE_MSC3088_PURPOSE.unstable) {
+                        // We use `unstable` to ensure that the code is actually using the right identifier
+                        expect(stateKey).toEqual(UNSTABLE_MSC3089_TREE_SUBTYPE.unstable);
+                        return new MatrixEvent({
+                            content: {
+                                [UNSTABLE_MSC3088_ENABLED.unstable]: true,
+                            },
+                        });
+                    } else {
+                        throw new Error("Unexpected event type or state key");
+                    }
+                },
+            },
+        };
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return mockRoom;
+        };
+        const tree = client.unstableGetFileTreeSpace(roomId);
+        expect(tree).toBeFalsy();
+    });
+
+    it("should not get (unstable) file trees with invalid purpose/subtype contents", async () => {
+        const roomId = "!room:example.org";
+        const mockRoom = {
+            getMyMembership: () => "join",
+            currentState: {
+                getStateEvents: (eventType, stateKey) => {
+                    if (eventType === EventType.RoomCreate) {
+                        expect(stateKey).toEqual("");
+                        return new MatrixEvent({
+                            content: {
+                                [RoomCreateTypeField]: RoomType.Space,
+                            },
+                        });
+                    } else if (eventType === UNSTABLE_MSC3088_PURPOSE.unstable) {
+                        expect(stateKey).toEqual(UNSTABLE_MSC3089_TREE_SUBTYPE.unstable);
+                        return new MatrixEvent({
+                            content: {
+                                [UNSTABLE_MSC3088_ENABLED.unstable]: false,
+                            },
+                        });
+                    } else {
+                        throw new Error("Unexpected event type or state key");
+                    }
+                },
+            },
+        };
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return mockRoom;
+        };
+        const tree = client.unstableGetFileTreeSpace(roomId);
+        expect(tree).toBeFalsy();
+    });
+
     it("should not POST /filter if a matching filter already exists", async function() {
         httpLookups = [];
         httpLookups.push(PUSH_RULES_RESPONSE);
@@ -178,7 +370,7 @@ describe("MatrixClient", function() {
         const filterId = "ehfewf";
         store.getFilterIdByName.mockReturnValue(filterId);
         const filter = new Filter(0, filterId);
-        filter.setDefinition({"room": {"timeline": {"limit": 8}}});
+        filter.setDefinition({ "room": { "timeline": { "limit": 8 } } });
         store.getFilter.mockReturnValue(filter);
         const syncPromise = new Promise((resolve, reject) => {
             client.on("sync", function syncListener(state) {
@@ -521,4 +713,19 @@ describe("MatrixClient", function() {
         xit("should be able to peek into a room using peekInRoom", function(done) {
         });
     });
+
+    describe("getPresence", function() {
+        it("should send a presence HTTP GET", function() {
+            httpLookups = [{
+                method: "GET",
+                path: `/presence/${encodeURIComponent(userId)}/status`,
+                data: {
+                    "presence": "unavailable",
+                    "last_active_ago": 420845,
+                },
+            }];
+            client.getPresence(userId);
+            expect(httpLookups.length).toEqual(0);
+        });
+    });
 });

spec/unit/models/MSC3089Branch.spec.ts

@@ -0,0 +1,332 @@
+/*
+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 { IContent, MatrixClient, MatrixEvent } from "../../../src";
+import { Room } from "../../../src/models/room";
+import { IEncryptedFile, RelationType, UNSTABLE_MSC3089_BRANCH } from "../../../src/@types/event";
+import { EventTimelineSet } from "../../../src/models/event-timeline-set";
+import { EventTimeline } from "../../../src/models/event-timeline";
+import { MSC3089Branch } from "../../../src/models/MSC3089Branch";
+import { MSC3089TreeSpace } from "../../../src/models/MSC3089TreeSpace";
+
+describe("MSC3089Branch", () => {
+    let client: MatrixClient;
+    // @ts-ignore - TS doesn't know that this is a type
+    let indexEvent: any;
+    let directory: MSC3089TreeSpace;
+    let branch: MSC3089Branch;
+    let branch2: MSC3089Branch;
+
+    const branchRoomId = "!room:example.org";
+    const fileEventId = "$file";
+    const fileEventId2 = "$second_file";
+
+    const staticTimelineSets = {} as EventTimelineSet;
+    const staticRoom = {
+        getUnfilteredTimelineSet: () => staticTimelineSets,
+    } as any as Room; // partial
+
+    beforeEach(() => {
+        // TODO: Use utility functions to create test rooms and clients
+        client = <MatrixClient>{
+            getRoom: (roomId: string) => {
+                if (roomId === branchRoomId) {
+                    return staticRoom;
+                } else {
+                    throw new Error("Unexpected fetch for unknown room");
+                }
+            },
+        };
+        indexEvent = ({
+            getRoomId: () => branchRoomId,
+            getStateKey: () => fileEventId,
+        });
+        directory = new MSC3089TreeSpace(client, branchRoomId);
+        branch = new MSC3089Branch(client, indexEvent, directory);
+        branch2 = new MSC3089Branch(client, {
+            getRoomId: () => branchRoomId,
+            getStateKey: () => fileEventId2,
+        } as MatrixEvent, directory);
+    });
+
+    it('should know the file event ID', () => {
+        expect(branch.id).toEqual(fileEventId);
+    });
+
+    it('should know if the file is active or not', () => {
+        indexEvent.getContent = () => ({});
+        expect(branch.isActive).toBe(false);
+        indexEvent.getContent = () => ({ active: false });
+        expect(branch.isActive).toBe(false);
+        indexEvent.getContent = () => ({ active: true });
+        expect(branch.isActive).toBe(true);
+        indexEvent.getContent = () => ({ active: "true" }); // invalid boolean, inactive
+        expect(branch.isActive).toBe(false);
+    });
+
+    it('should be able to delete the file', async () => {
+        const eventIdOrder = [fileEventId, fileEventId2];
+
+        const stateFn = jest.fn()
+            .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
+                expect(roomId).toEqual(branchRoomId);
+                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
+                expect(content).toMatchObject({});
+                expect(content['active']).toBeUndefined();
+                expect(stateKey).toEqual(eventIdOrder[stateFn.mock.calls.length - 1]);
+
+                return Promise.resolve(); // return value not used
+            });
+        client.sendStateEvent = stateFn;
+
+        const redactFn = jest.fn().mockImplementation((roomId: string, eventId: string) => {
+            expect(roomId).toEqual(branchRoomId);
+            expect(eventId).toEqual(eventIdOrder[stateFn.mock.calls.length - 1]);
+
+            return Promise.resolve(); // return value not used
+        });
+        client.redactEvent = redactFn;
+
+        branch.getVersionHistory = () => Promise.resolve([branch, branch2]);
+        branch2.getVersionHistory = () => Promise.resolve([branch2]);
+
+        await branch.delete();
+
+        expect(stateFn).toHaveBeenCalledTimes(2);
+        expect(redactFn).toHaveBeenCalledTimes(2);
+    });
+
+    it('should know its name', async () => {
+        const name = "My File.txt";
+        indexEvent.getContent = () => ({ active: true, name: name });
+
+        const res = branch.getName();
+
+        expect(res).toEqual(name);
+    });
+
+    it('should be able to change its name', async () => {
+        const name = "My File.txt";
+        indexEvent.getContent = () => ({ active: true, retained: true });
+        const stateFn = jest.fn()
+            .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
+                expect(roomId).toEqual(branchRoomId);
+                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
+                expect(content).toMatchObject({
+                    retained: true, // canary for copying state
+                    active: true,
+                    name: name,
+                });
+                expect(stateKey).toEqual(fileEventId);
+
+                return Promise.resolve(); // return value not used
+            });
+        client.sendStateEvent = stateFn;
+
+        await branch.setName(name);
+
+        expect(stateFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should be v1 by default', () => {
+        indexEvent.getContent = () => ({ active: true });
+
+        const res = branch.version;
+
+        expect(res).toEqual(1);
+    });
+
+    it('should be vN when set', () => {
+        indexEvent.getContent = () => ({ active: true, version: 3 });
+
+        const res = branch.version;
+
+        expect(res).toEqual(3);
+    });
+
+    it('should be unlocked by default', async () => {
+        indexEvent.getContent = () => ({ active: true });
+
+        const res = branch.isLocked();
+
+        expect(res).toEqual(false);
+    });
+
+    it('should use lock status from index event', async () => {
+        indexEvent.getContent = () => ({ active: true, locked: true });
+
+        const res = branch.isLocked();
+
+        expect(res).toEqual(true);
+    });
+
+    it('should be able to change its locked status', async () => {
+        const locked = true;
+        indexEvent.getContent = () => ({ active: true, retained: true });
+        const stateFn = jest.fn()
+            .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
+                expect(roomId).toEqual(branchRoomId);
+                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
+                expect(content).toMatchObject({
+                    retained: true, // canary for copying state
+                    active: true,
+                    locked: locked,
+                });
+                expect(stateKey).toEqual(fileEventId);
+
+                return Promise.resolve(); // return value not used
+            });
+        client.sendStateEvent = stateFn;
+
+        await branch.setLocked(locked);
+
+        expect(stateFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should be able to return event information', async () => {
+        const mxcLatter = "example.org/file";
+        const fileContent = { isFile: "not quite", url: "mxc://" + mxcLatter };
+        const fileEvent = { getId: () => fileEventId, getOriginalContent: () => ({ file: fileContent }) };
+        staticRoom.getUnfilteredTimelineSet = () => ({
+            findEventById: (eventId) => {
+                expect(eventId).toEqual(fileEventId);
+                return fileEvent;
+            },
+        }) as EventTimelineSet;
+        client.mxcUrlToHttp = (mxc: string) => {
+            expect(mxc).toEqual("mxc://" + mxcLatter);
+            return `https://example.org/_matrix/media/v1/download/${mxcLatter}`;
+        };
+        client.decryptEventIfNeeded = () => Promise.resolve();
+
+        const res = await branch.getFileInfo();
+        expect(res).toBeDefined();
+        expect(res).toMatchObject({
+            info: fileContent,
+            // Escape regex from MDN guides: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
+            httpUrl: expect.stringMatching(`.+${mxcLatter.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`),
+        });
+    });
+
+    it('should be able to return the event object', async () => {
+        const mxcLatter = "example.org/file";
+        const fileContent = { isFile: "not quite", url: "mxc://" + mxcLatter };
+        const fileEvent = { getId: () => fileEventId, getOriginalContent: () => ({ file: fileContent }) };
+        staticRoom.getUnfilteredTimelineSet = () => ({
+            findEventById: (eventId) => {
+                expect(eventId).toEqual(fileEventId);
+                return fileEvent;
+            },
+        }) as EventTimelineSet;
+        client.mxcUrlToHttp = (mxc: string) => {
+            expect(mxc).toEqual("mxc://" + mxcLatter);
+            return `https://example.org/_matrix/media/v1/download/${mxcLatter}`;
+        };
+        client.decryptEventIfNeeded = () => Promise.resolve();
+
+        const res = await branch.getFileEvent();
+        expect(res).toBeDefined();
+        expect(res).toBe(fileEvent);
+    });
+
+    it('should create new versions of itself', async () => {
+        const canaryName = "canary";
+        const fileContents = "contents go here";
+        const canaryContents = Uint8Array.from(Array.from(fileContents).map((_, i) => fileContents.charCodeAt(i)));
+        const canaryFile = {} as IEncryptedFile;
+        const canaryAddl = { canary: true };
+        indexEvent.getContent = () => ({ active: true, retained: true });
+        const stateKeyOrder = [fileEventId2, fileEventId];
+        const stateFn = jest.fn()
+            .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
+                expect(roomId).toEqual(branchRoomId);
+                expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
+                expect(stateKey).toEqual(stateKeyOrder[stateFn.mock.calls.length - 1]);
+                if (stateKey === fileEventId) {
+                    expect(content).toMatchObject({
+                        retained: true, // canary for copying state
+                        active: false,
+                    });
+                } else if (stateKey === fileEventId2) {
+                    expect(content).toMatchObject({
+                        active: true,
+                        version: 2,
+                        name: canaryName,
+                    });
+                } else {
+                    throw new Error("Unexpected state key: " + stateKey);
+                }
+
+                return Promise.resolve(); // return value not used
+            });
+        client.sendStateEvent = stateFn;
+
+        const createFn = jest.fn().mockImplementation((
+            name: string,
+            contents: ArrayBuffer,
+            info: Partial<IEncryptedFile>,
+            addl: IContent,
+        ) => {
+            expect(name).toEqual(canaryName);
+            expect(contents).toBe(canaryContents);
+            expect(info).toBe(canaryFile);
+            expect(addl).toMatchObject({
+                ...canaryAddl,
+                "m.new_content": true,
+                "m.relates_to": {
+                    "rel_type": RelationType.Replace,
+                    "event_id": fileEventId,
+                },
+            });
+
+            return Promise.resolve({ event_id: fileEventId2 });
+        });
+        directory.createFile = createFn;
+
+        await branch.createNewVersion(canaryName, canaryContents, canaryFile, canaryAddl);
+
+        expect(stateFn).toHaveBeenCalledTimes(2);
+        expect(createFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should fetch file history', async () => {
+        branch2.getFileEvent = () => Promise.resolve({
+            replacingEventId: () => undefined,
+            getId: () => fileEventId2,
+        } as MatrixEvent);
+        branch.getFileEvent = () => Promise.resolve({
+            replacingEventId: () => fileEventId2,
+            getId: () => fileEventId,
+        } as MatrixEvent);
+
+        const events = [await branch.getFileEvent(), await branch2.getFileEvent(), {
+            replacingEventId: () => null,
+            getId: () => "$unknown",
+        }];
+        staticRoom.getLiveTimeline = () => ({ getEvents: () => events }) as EventTimeline;
+
+        directory.getFile = (evId: string) => {
+            expect(evId).toEqual(fileEventId);
+            return branch;
+        };
+
+        const results = await branch2.getVersionHistory();
+        expect(results).toMatchObject([
+            branch2,
+            branch,
+        ]);
+    });
+});

spec/unit/models/event.spec.ts

@@ -0,0 +1,60 @@
+/*
+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 { MatrixEvent } from "../../../src/models/event";
+
+describe('MatrixEvent', () => {
+    it('should create copies of itself', () => {
+        const a = new MatrixEvent({
+            type: "com.example.test",
+            content: {
+                isTest: true,
+                num: 42,
+            },
+        });
+
+        const clone = a.toSnapshot();
+        expect(clone).toBeDefined();
+        expect(clone).not.toBe(a);
+        expect(clone.event).not.toBe(a.event);
+        expect(clone.event).toMatchObject(a.event);
+
+        // The other properties we're not super interested in, honestly.
+    });
+
+    it('should compare itself to other events using json', () => {
+        const a = new MatrixEvent({
+            type: "com.example.test",
+            content: {
+                isTest: true,
+                num: 42,
+            },
+        });
+        const b = new MatrixEvent({
+            type: "com.example.test______B",
+            content: {
+                isTest: true,
+                num: 42,
+            },
+        });
+        expect(a.isEquivalentTo(b)).toBe(false);
+        expect(a.isEquivalentTo(a)).toBe(true);
+        expect(b.isEquivalentTo(a)).toBe(false);
+        expect(b.isEquivalentTo(b)).toBe(true);
+        expect(a.toSnapshot().isEquivalentTo(a)).toBe(true);
+        expect(a.toSnapshot().isEquivalentTo(b)).toBe(false);
+    });
+});

spec/unit/pushprocessor.spec.js

@@ -1,5 +1,5 @@
 import * as utils from "../test-utils";
-import {PushProcessor} from "../../src/pushprocessor";
+import { PushProcessor } from "../../src/pushprocessor";
 
 describe('NotificationService', function() {
     const testUserId = "@ali:matrix.org";

spec/unit/realtime-callbacks.spec.js

@@ -46,8 +46,8 @@ describe("realtime-callbacks", function() {
         it("should set 'this' to the global object", function() {
             let passed = false;
             const callback = function() {
-                expect(this).toBe(global); // eslint-disable-line babel/no-invalid-this
-                expect(this.console).toBeTruthy(); // eslint-disable-line babel/no-invalid-this
+                expect(this).toBe(global); // eslint-disable-line @babel/no-invalid-this
+                expect(this.console).toBeTruthy(); // eslint-disable-line @babel/no-invalid-this
                 passed = true;
             };
             callbacks.setTimeout(callback);

spec/unit/relations.spec.ts

@@ -0,0 +1,133 @@
+/*
+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 { EventTimelineSet } from "../../src/models/event-timeline-set";
+import { MatrixEvent } from "../../src/models/event";
+import { Room } from "../../src/models/room";
+import { Relations } from "../../src/models/relations";
+
+describe("Relations", function() {
+    it("should deduplicate annotations", function() {
+        const room = new Room("room123", null, null);
+        const relations = new Relations("m.annotation", "m.reaction", room);
+
+        // Create an instance of an annotation
+        const eventData = {
+            "sender": "@bob:example.com",
+            "type": "m.reaction",
+            "event_id": "$cZ1biX33ENJqIm00ks0W_hgiO_6CHrsAc3ZQrnLeNTw",
+            "room_id": "!pzVjCQSoQPpXQeHpmK:example.com",
+            "content": {
+                "m.relates_to": {
+                    "event_id": "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
+                    "key": "👍️",
+                    "rel_type": "m.annotation",
+                },
+            },
+        };
+        const eventA = new MatrixEvent(eventData);
+
+        // Add the event once and check results
+        {
+            relations.addEvent(eventA);
+            const annotationsByKey = relations.getSortedAnnotationsByKey();
+            expect(annotationsByKey.length).toEqual(1);
+            const [key, events] = annotationsByKey[0];
+            expect(key).toEqual("👍️");
+            expect(events.size).toEqual(1);
+        }
+
+        // Add the event again and expect the same
+        {
+            relations.addEvent(eventA);
+            const annotationsByKey = relations.getSortedAnnotationsByKey();
+            expect(annotationsByKey.length).toEqual(1);
+            const [key, events] = annotationsByKey[0];
+            expect(key).toEqual("👍️");
+            expect(events.size).toEqual(1);
+        }
+
+        // Create a fresh object with the same event content
+        const eventB = new MatrixEvent(eventData);
+
+        // Add the event again and expect the same
+        {
+            relations.addEvent(eventB);
+            const annotationsByKey = relations.getSortedAnnotationsByKey();
+            expect(annotationsByKey.length).toEqual(1);
+            const [key, events] = annotationsByKey[0];
+            expect(key).toEqual("👍️");
+            expect(events.size).toEqual(1);
+        }
+    });
+
+    it("should emit created regardless of ordering", async function() {
+        const targetEvent = new MatrixEvent({
+            "sender": "@bob:example.com",
+            "type": "m.room.message",
+            "event_id": "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
+            "room_id": "!pzVjCQSoQPpXQeHpmK:example.com",
+            "content": {},
+        });
+        const relationEvent = new MatrixEvent({
+            "sender": "@bob:example.com",
+            "type": "m.reaction",
+            "event_id": "$cZ1biX33ENJqIm00ks0W_hgiO_6CHrsAc3ZQrnLeNTw",
+            "room_id": "!pzVjCQSoQPpXQeHpmK:example.com",
+            "content": {
+                "m.relates_to": {
+                    "event_id": "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
+                    "key": "👍️",
+                    "rel_type": "m.annotation",
+                },
+            },
+        });
+
+        // Stub the room
+
+        const room = new Room("room123", null, null);
+
+        // Add the target event first, then the relation event
+        {
+            const relationsCreated = new Promise(resolve => {
+                targetEvent.once("Event.relationsCreated", resolve);
+            });
+
+            const timelineSet = new EventTimelineSet(room, {
+                unstableClientRelationAggregation: true,
+            });
+            timelineSet.addLiveEvent(targetEvent);
+            timelineSet.addLiveEvent(relationEvent);
+
+            await relationsCreated;
+        }
+
+        // Add the relation event first, then the target event
+        {
+            const relationsCreated = new Promise(resolve => {
+                targetEvent.once("Event.relationsCreated", resolve);
+            });
+
+            const timelineSet = new EventTimelineSet(room, {
+                unstableClientRelationAggregation: true,
+            });
+            timelineSet.addLiveEvent(relationEvent);
+            timelineSet.addLiveEvent(targetEvent);
+
+            await relationsCreated;
+        }
+    });
+});

spec/unit/room-member.spec.js

@@ -1,5 +1,5 @@
 import * as utils from "../test-utils";
-import {RoomMember} from "../../src/models/room-member";
+import { RoomMember } from "../../src/models/room-member";
 
 describe("RoomMember", function() {
     const roomId = "!foo:bar";
@@ -33,12 +33,6 @@ describe("RoomMember", function() {
             expect(url.indexOf("flibble/wibble")).not.toEqual(-1);
         });
 
-        it("should return an identicon HTTP URL if allowDefault was set and there " +
-        "was no m.room.member event", function() {
-            const url = member.getAvatarUrl(hsUrl, 64, 64, "crop", true);
-            expect(url.indexOf("http")).toEqual(0); // don't care about form
-        });
-
         it("should return nothing if there is no m.room.member and allowDefault=false",
         function() {
             const url = member.getAvatarUrl(hsUrl, 64, 64, "crop", false);
@@ -130,6 +124,34 @@ describe("RoomMember", function() {
             expect(member.powerLevel).toEqual(0);
             expect(emitCount).toEqual(1);
         });
+
+        it("should not honor string power levels.",
+        function() {
+            const event = utils.mkEvent({
+                type: "m.room.power_levels",
+                room: roomId,
+                user: userA,
+                content: {
+                    users_default: 20,
+                    users: {
+                        "@alice:bar": "5",
+                    },
+                },
+                event: true,
+            });
+            let emitCount = 0;
+
+            member.on("RoomMember.powerLevel", function(emitEvent, emitMember) {
+                emitCount += 1;
+                expect(emitMember.userId).toEqual('@alice:bar');
+                expect(emitMember.powerLevel).toEqual(20);
+                expect(emitEvent).toEqual(event);
+            });
+
+            member.setPowerLevelEvent(event);
+            expect(member.powerLevel).toEqual(20);
+            expect(emitCount).toEqual(1);
+        });
     });
 
     describe("setTypingEvent", function() {

spec/unit/room-state.spec.js

@@ -1,6 +1,5 @@
 import * as utils from "../test-utils";
-import {RoomState} from "../../src/models/room-state";
-import {RoomMember} from "../../src/models/room-member";
+import { RoomState } from "../../src/models/room-state";
 
 describe("RoomState", function() {
     const roomId = "!foo:bar";
@@ -193,12 +192,7 @@ describe("RoomState", function() {
             expect(emitCount).toEqual(2);
         });
 
-        it("should call setPowerLevelEvent on each RoomMember for m.room.power_levels",
-        function() {
-            // mock up the room members
-            state.members[userA] = utils.mock(RoomMember);
-            state.members[userB] = utils.mock(RoomMember);
-
+        it("should call setPowerLevelEvent on each RoomMember for m.room.power_levels", function() {
             const powerLevelEvent = utils.mkEvent({
                 type: "m.room.power_levels", room: roomId, user: userA, event: true,
                 content: {
@@ -208,18 +202,16 @@ describe("RoomState", function() {
                 },
             });
 
+            // spy on the room members
+            jest.spyOn(state.members[userA], "setPowerLevelEvent");
+            jest.spyOn(state.members[userB], "setPowerLevelEvent");
             state.setStateEvents([powerLevelEvent]);
 
-            expect(state.members[userA].setPowerLevelEvent).toHaveBeenCalledWith(
-                powerLevelEvent,
-            );
-            expect(state.members[userB].setPowerLevelEvent).toHaveBeenCalledWith(
-                powerLevelEvent,
-            );
+            expect(state.members[userA].setPowerLevelEvent).toHaveBeenCalledWith(powerLevelEvent);
+            expect(state.members[userB].setPowerLevelEvent).toHaveBeenCalledWith(powerLevelEvent);
         });
 
-        it("should call setPowerLevelEvent on a new RoomMember if power levels exist",
-        function() {
+        it("should call setPowerLevelEvent on a new RoomMember if power levels exist", function() {
             const memberEvent = utils.mkMembership({
                 mship: "join", user: userC, room: roomId, event: true,
             });
@@ -243,13 +235,12 @@ describe("RoomState", function() {
         });
 
         it("should call setMembershipEvent on the right RoomMember", function() {
-            // mock up the room members
-            state.members[userA] = utils.mock(RoomMember);
-            state.members[userB] = utils.mock(RoomMember);
-
             const memberEvent = utils.mkMembership({
                 user: userB, mship: "leave", room: roomId, event: true,
             });
+            // spy on the room members
+            jest.spyOn(state.members[userA], "setMembershipEvent");
+            jest.spyOn(state.members[userB], "setMembershipEvent");
             state.setStateEvents([memberEvent]);
 
             expect(state.members[userA].setMembershipEvent).not.toHaveBeenCalled();
@@ -374,17 +365,13 @@ describe("RoomState", function() {
                     user_ids: [userA],
                 },
             });
-            // mock up the room members
-            state.members[userA] = utils.mock(RoomMember);
-            state.members[userB] = utils.mock(RoomMember);
+            // spy on the room members
+            jest.spyOn(state.members[userA], "setTypingEvent");
+            jest.spyOn(state.members[userB], "setTypingEvent");
             state.setTypingEvent(typingEvent);
 
-            expect(state.members[userA].setTypingEvent).toHaveBeenCalledWith(
-                typingEvent,
-            );
-            expect(state.members[userB].setTypingEvent).toHaveBeenCalledWith(
-                typingEvent,
-            );
+            expect(state.members[userA].setTypingEvent).toHaveBeenCalledWith(typingEvent);
+            expect(state.members[userB].setTypingEvent).toHaveBeenCalledWith(typingEvent);
         });
     });
 
@@ -471,13 +458,13 @@ describe("RoomState", function() {
 
         it("should update after adding joined member", function() {
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "join",
-                    user: userA, room: roomId}),
+                utils.mkMembership({ event: true, mship: "join",
+                    user: userA, room: roomId }),
             ]);
             expect(state.getJoinedMemberCount()).toEqual(1);
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "join",
-                    user: userC, room: roomId}),
+                utils.mkMembership({ event: true, mship: "join",
+                    user: userC, room: roomId }),
             ]);
             expect(state.getJoinedMemberCount()).toEqual(2);
         });
@@ -490,13 +477,13 @@ describe("RoomState", function() {
 
         it("should update after adding invited member", function() {
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "invite",
-                    user: userA, room: roomId}),
+                utils.mkMembership({ event: true, mship: "invite",
+                    user: userA, room: roomId }),
             ]);
             expect(state.getInvitedMemberCount()).toEqual(1);
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "invite",
-                    user: userC, room: roomId}),
+                utils.mkMembership({ event: true, mship: "invite",
+                    user: userC, room: roomId }),
             ]);
             expect(state.getInvitedMemberCount()).toEqual(2);
         });
@@ -509,15 +496,15 @@ describe("RoomState", function() {
 
         it("should, once used, override counting members from state", function() {
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "join",
-                    user: userA, room: roomId}),
+                utils.mkMembership({ event: true, mship: "join",
+                    user: userA, room: roomId }),
             ]);
             expect(state.getJoinedMemberCount()).toEqual(1);
             state.setJoinedMemberCount(100);
             expect(state.getJoinedMemberCount()).toEqual(100);
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "join",
-                    user: userC, room: roomId}),
+                utils.mkMembership({ event: true, mship: "join",
+                    user: userC, room: roomId }),
             ]);
             expect(state.getJoinedMemberCount()).toEqual(100);
         });
@@ -525,14 +512,14 @@ describe("RoomState", function() {
         it("should, once used, override counting members from state, " +
         "also after clone", function() {
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "join",
-                    user: userA, room: roomId}),
+                utils.mkMembership({ event: true, mship: "join",
+                    user: userA, room: roomId }),
             ]);
             state.setJoinedMemberCount(100);
             const copy = state.clone();
             copy.setStateEvents([
-                utils.mkMembership({event: true, mship: "join",
-                    user: userC, room: roomId}),
+                utils.mkMembership({ event: true, mship: "join",
+                    user: userC, room: roomId }),
             ]);
             expect(state.getJoinedMemberCount()).toEqual(100);
         });
@@ -545,15 +532,15 @@ describe("RoomState", function() {
 
         it("should, once used, override counting members from state", function() {
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "invite",
-                    user: userB, room: roomId}),
+                utils.mkMembership({ event: true, mship: "invite",
+                    user: userB, room: roomId }),
             ]);
             expect(state.getInvitedMemberCount()).toEqual(1);
             state.setInvitedMemberCount(100);
             expect(state.getInvitedMemberCount()).toEqual(100);
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "invite",
-                    user: userC, room: roomId}),
+                utils.mkMembership({ event: true, mship: "invite",
+                    user: userC, room: roomId }),
             ]);
             expect(state.getInvitedMemberCount()).toEqual(100);
         });
@@ -561,14 +548,14 @@ describe("RoomState", function() {
         it("should, once used, override counting members from state, " +
         "also after clone", function() {
             state.setStateEvents([
-                utils.mkMembership({event: true, mship: "invite",
-                    user: userB, room: roomId}),
+                utils.mkMembership({ event: true, mship: "invite",
+                    user: userB, room: roomId }),
             ]);
             state.setInvitedMemberCount(100);
             const copy = state.clone();
             copy.setStateEvents([
-                utils.mkMembership({event: true, mship: "invite",
-                    user: userC, room: roomId}),
+                utils.mkMembership({ event: true, mship: "invite",
+                    user: userC, room: roomId }),
             ]);
             expect(state.getInvitedMemberCount()).toEqual(100);
         });

spec/unit/room.spec.js

@@ -1,8 +1,10 @@
 import * as utils from "../test-utils";
-import {EventStatus, MatrixEvent} from "../../src/models/event";
-import {EventTimeline} from "../../src/models/event-timeline";
-import {RoomState} from "../../src/models/room-state";
-import {Room} from "../../src/models/room";
+import { DuplicateStrategy, EventStatus, MatrixEvent } from "../../src";
+import { EventTimeline } from "../../src/models/event-timeline";
+import { RoomState } from "../../src";
+import { Room } from "../../src";
+import { UNSTABLE_ELEMENT_FUNCTIONAL_USERS } from "../../src/@types/event";
+import { TestClient } from "../TestClient";
 
 describe("Room", function() {
     const roomId = "!foo:bar";
@@ -15,9 +17,9 @@ describe("Room", function() {
     beforeEach(function() {
         room = new Room(roomId);
         // mock RoomStates
-        room.oldState = room.getLiveTimeline()._startState =
+        room.oldState = room.getLiveTimeline().startState =
             utils.mock(RoomState, "oldState");
-        room.currentState = room.getLiveTimeline()._endState =
+        room.currentState = room.getLiveTimeline().endState =
             utils.mock(RoomState, "currentState");
     });
 
@@ -45,12 +47,6 @@ describe("Room", function() {
             expect(url.indexOf("flibble/wibble")).not.toEqual(-1);
         });
 
-        it("should return an identicon HTTP URL if allowDefault was set and there " +
-        "was no m.room.avatar event", function() {
-            const url = room.getAvatarUrl(hsUrl, 64, 64, "crop", true);
-            expect(url.indexOf("http")).toEqual(0); // don't care about form
-        });
-
         it("should return nothing if there is no m.room.avatar and allowDefault=false",
         function() {
             const url = room.getAvatarUrl(hsUrl, 64, 64, "crop", false);
@@ -91,9 +87,11 @@ describe("Room", function() {
         ];
 
         it("should call RoomState.setTypingEvent on m.typing events", function() {
-            room.currentState = utils.mock(RoomState);
             const typing = utils.mkEvent({
-                room: roomId, type: "m.typing", event: true, content: {
+                room: roomId,
+                type: "m.typing",
+                event: true,
+                content: {
                     user_ids: [userA],
                 },
             });
@@ -115,7 +113,7 @@ describe("Room", function() {
             dupe.event.event_id = events[0].getId();
             room.addLiveEvents(events);
             expect(room.timeline[0]).toEqual(events[0]);
-            room.addLiveEvents([dupe], "replace");
+            room.addLiveEvents([dupe], DuplicateStrategy.Replace);
             expect(room.timeline[0]).toEqual(dupe);
         });
 
@@ -145,8 +143,8 @@ describe("Room", function() {
             expect(callCount).toEqual(2);
         });
 
-        it("should call setStateEvents on the right RoomState with the right " +
-        "forwardLooking value for new events", function() {
+        it("should call setStateEvents on the right RoomState with the right forwardLooking value for new events",
+        function() {
             const events = [
                 utils.mkMembership({
                     room: roomId, mship: "invite", user: userB, skey: userA, event: true,
@@ -196,7 +194,7 @@ describe("Room", function() {
             const remoteEvent = utils.mkMessage({
                 room: roomId, user: userA, event: true,
             });
-            remoteEvent.event.unsigned = {transaction_id: "TXN_ID"};
+            remoteEvent.event.unsigned = { transaction_id: "TXN_ID" };
             const remoteEventId = remoteEvent.getId();
 
             let callCount = 0;
@@ -380,7 +378,7 @@ describe("Room", function() {
         let events = null;
 
         beforeEach(function() {
-            room = new Room(roomId, null, null, {timelineSupport: timelineSupport});
+            room = new Room(roomId, null, null, { timelineSupport: timelineSupport });
             // set events each time to avoid resusing Event objects (which
             // doesn't work because they get frozen)
             events = [
@@ -462,7 +460,7 @@ describe("Room", function() {
 
     describe("compareEventOrdering", function() {
         beforeEach(function() {
-            room = new Room(roomId, null, null, {timelineSupport: true});
+            room = new Room(roomId, null, null, { timelineSupport: true });
         });
 
         const events = [
@@ -657,7 +655,8 @@ describe("Room", function() {
                 const roomName = "flibble";
 
                 const event = addMember(userA, "invite");
-                event.event.invite_room_state = [
+                event.event.unsigned = {};
+                event.event.unsigned.invite_room_state = [
                     {
                         type: "m.room.name",
                         state_key: "",
@@ -676,7 +675,8 @@ describe("Room", function() {
                 const roomName = "flibble";
                 setRoomName(roomName);
                 const roomNameToIgnore = "ignoreme";
-                event.event.invite_room_state = [
+                event.event.unsigned = {};
+                event.event.unsigned.invite_room_state = [
                     {
                         type: "m.room.name",
                         state_key: "",
@@ -718,7 +718,7 @@ describe("Room", function() {
             it("uses hero name from state", function() {
                 const name = "Mr B";
                 addMember(userA, "invite");
-                addMember(userB, "join", {name});
+                addMember(userB, "join", { name });
                 room.setSummary({
                     "m.heroes": [userB],
                 });
@@ -729,7 +729,7 @@ describe("Room", function() {
 
             it("uses counts from summary", function() {
                 const name = "Mr B";
-                addMember(userB, "join", {name});
+                addMember(userB, "join", { name });
                 room.setSummary({
                     "m.heroes": [userB],
                     "m.joined_member_count": 50,
@@ -742,8 +742,8 @@ describe("Room", function() {
             it("relies on heroes in case of absent counts", function() {
                 const nameB = "Mr Bean";
                 const nameC = "Mel C";
-                addMember(userB, "join", {name: nameB});
-                addMember(userC, "join", {name: nameC});
+                addMember(userB, "join", { name: nameB });
+                addMember(userC, "join", { name: nameC });
                 room.setSummary({
                     "m.heroes": [userB, userC],
                 });
@@ -753,7 +753,7 @@ describe("Room", function() {
 
             it("uses only heroes", function() {
                 const nameB = "Mr Bean";
-                addMember(userB, "join", {name: nameB});
+                addMember(userB, "join", { name: nameB });
                 addMember(userC, "join");
                 room.setSummary({
                     "m.heroes": [userB],
@@ -846,7 +846,7 @@ describe("Room", function() {
             it("should show the other user's name for private" +
             " (invite join_rules) rooms if you are invited to it.", function() {
                 setJoinRule("invite");
-                addMember(userA, "invite", {user: userB});
+                addMember(userA, "invite", { user: userB });
                 addMember(userB);
                 room.recalculate();
                 const name = room.name;
@@ -921,8 +921,8 @@ describe("Room", function() {
                "available",
             function() {
                 setJoinRule("invite");
-                addMember(userB, 'join', {name: "Alice"});
-                addMember(userA, "invite", {user: userA});
+                addMember(userB, 'join', { name: "Alice" });
+                addMember(userA, "invite", { user: userA });
                 room.recalculate();
                 const name = room.name;
                 expect(name).toEqual("Alice");
@@ -932,7 +932,7 @@ describe("Room", function() {
             function() {
                 setJoinRule("invite");
                 addMember(userB);
-                addMember(userA, "invite", {user: userA});
+                addMember(userA, "invite", { user: userA });
                 room.recalculate();
                 const name = room.name;
                 expect(name).toEqual(userB);
@@ -1182,7 +1182,10 @@ describe("Room", function() {
     describe("addPendingEvent", function() {
         it("should add pending events to the pendingEventList if " +
                       "pendingEventOrdering == 'detached'", function() {
-            const room = new Room(roomId, null, userA, {
+            const client = (new TestClient(
+                "@alice:example.com", "alicedevice",
+            )).client;
+            const room = new Room(roomId, client, userA, {
                 pendingEventOrdering: "detached",
             });
             const eventA = utils.mkMessage({
@@ -1232,7 +1235,10 @@ describe("Room", function() {
 
     describe("updatePendingEvent", function() {
         it("should remove cancelled events from the pending list", function() {
-            const room = new Room(roomId, null, userA, {
+            const client = (new TestClient(
+                "@alice:example.com", "alicedevice",
+            )).client;
+            const room = new Room(roomId, client, userA, {
                 pendingEventOrdering: "detached",
             });
             const eventA = utils.mkMessage({
@@ -1266,7 +1272,6 @@ describe("Room", function() {
             expect(callCount).toEqual(1);
         });
 
-
         it("should remove cancelled events from the timeline", function() {
             const room = new Room(roomId, null, userA);
             const eventA = utils.mkMessage({
@@ -1314,13 +1319,13 @@ describe("Room", function() {
                 isRoomEncrypted: function() {
                     return false;
                 },
-                _http: {
+                http: {
                     serverResponse,
                     authedRequest: function() {
                         if (this.serverResponse instanceof Error) {
                             return Promise.reject(this.serverResponse);
                         } else {
-                            return Promise.resolve({chunk: this.serverResponse});
+                            return Promise.resolve({ chunk: this.serverResponse });
                         }
                     },
                 },
@@ -1350,7 +1355,7 @@ describe("Room", function() {
 
         it("should load members from server on first call", async function() {
             const client = createClientMock([memberEvent]);
-            const room = new Room(roomId, client, null, {lazyLoadMembers: true});
+            const room = new Room(roomId, client, null, { lazyLoadMembers: true });
             await room.loadMembersIfNeeded();
             const memberA = room.getMember("@user_a:bar");
             expect(memberA.name).toEqual("User A");
@@ -1365,7 +1370,7 @@ describe("Room", function() {
                 room: roomId, event: true, name: "Ms A",
             });
             const client = createClientMock([memberEvent2], [memberEvent]);
-            const room = new Room(roomId, client, null, {lazyLoadMembers: true});
+            const room = new Room(roomId, client, null, { lazyLoadMembers: true });
 
             await room.loadMembersIfNeeded();
 
@@ -1375,16 +1380,16 @@ describe("Room", function() {
 
         it("should allow retry on error", async function() {
             const client = createClientMock(new Error("server says no"));
-            const room = new Room(roomId, client, null, {lazyLoadMembers: true});
+            const room = new Room(roomId, client, null, { lazyLoadMembers: true });
             let hasThrown = false;
             try {
                 await room.loadMembersIfNeeded();
-            } catch(err) {
+            } catch (err) {
                 hasThrown = true;
             }
             expect(hasThrown).toEqual(true);
 
-            client._http.serverResponse = [memberEvent];
+            client.http.serverResponse = [memberEvent];
             await room.loadMembersIfNeeded();
             const memberA = room.getMember("@user_a:bar");
             expect(memberA.name).toEqual("User A");
@@ -1403,17 +1408,17 @@ describe("Room", function() {
             const room = new Room(roomId, null, userA);
             const events = [];
             room.on("Room.myMembership", (_room, membership, oldMembership) => {
-                events.push({membership, oldMembership});
+                events.push({ membership, oldMembership });
             });
             room.updateMyMembership("invite");
             expect(room.getMyMembership()).toEqual("invite");
-            expect(events[0]).toEqual({membership: "invite", oldMembership: null});
+            expect(events[0]).toEqual({ membership: "invite", oldMembership: null });
             events.splice(0);   //clear
             room.updateMyMembership("invite");
             expect(events.length).toEqual(0);
             room.updateMyMembership("join");
             expect(room.getMyMembership()).toEqual("join");
-            expect(events[0]).toEqual({membership: "join", oldMembership: "invite"});
+            expect(events[0]).toEqual({ membership: "join", oldMembership: "invite" });
         });
     });
 
@@ -1421,7 +1426,7 @@ describe("Room", function() {
         it("should return first hero id",
         function() {
             const room = new Room(roomId, null, userA);
-            room.setSummary({'m.heroes': [userB]});
+            room.setSummary({ 'm.heroes': [userB] });
             expect(room.guessDMUserId()).toEqual(userB);
         });
         it("should return first member that isn't self",
@@ -1452,4 +1457,291 @@ describe("Room", function() {
             expect(room.maySendMessage()).toEqual(true);
         });
     });
+
+    describe("getDefaultRoomName", function() {
+        it("should return 'Empty room' if a user is the only member",
+        function() {
+            const room = new Room(roomId, null, userA);
+            expect(room.getDefaultRoomName(userA)).toEqual("Empty room");
+        });
+
+        it("should return a display name if one other member is in the room",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "join",
+                    room: roomId, event: true, name: "User B",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("User B");
+        });
+
+        it("should return a display name if one other member is banned",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "ban",
+                    room: roomId, event: true, name: "User B",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("Empty room (was User B)");
+        });
+
+        it("should return a display name if one other member is invited",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "invite",
+                    room: roomId, event: true, name: "User B",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("User B");
+        });
+
+        it("should return 'Empty room (was User B)' if User B left the room",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "leave",
+                    room: roomId, event: true, name: "User B",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("Empty room (was User B)");
+        });
+
+        it("should return 'User B and User C' if in a room with two other users",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "join",
+                    room: roomId, event: true, name: "User B",
+                }),
+                utils.mkMembership({
+                    user: userC, mship: "join",
+                    room: roomId, event: true, name: "User C",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("User B and User C");
+        });
+
+        it("should return 'User B and 2 others' if in a room with three other users",
+        function() {
+            const room = new Room(roomId, null, userA);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userA, mship: "join",
+                    room: roomId, event: true, name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB, mship: "join",
+                    room: roomId, event: true, name: "User B",
+                }),
+                utils.mkMembership({
+                    user: userC, mship: "join",
+                    room: roomId, event: true, name: "User C",
+                }),
+                utils.mkMembership({
+                    user: userD, mship: "join",
+                    room: roomId, event: true, name: "User D",
+                }),
+            ]);
+            expect(room.getDefaultRoomName(userA)).toEqual("User B and 2 others");
+        });
+
+        describe("io.element.functional_users", function() {
+            it("should return a display name (default behaviour) if no one is marked as a functional member",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true,
+                        content: {
+                            service_members: [],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+
+            it("should return a display name (default behaviour) if service members is a number (invalid)",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true,
+                        content: {
+                            service_members: 1,
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+
+            it("should return a display name (default behaviour) if service members is a string (invalid)",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true,
+                        content: {
+                            service_members: userB,
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+
+            it("should return 'Empty room' if the only other member is a functional member",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true,
+                        content: {
+                            service_members: [userB],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("Empty room");
+            });
+
+            it("should return 'User B' if User B is the only other member who isn't a functional member",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkMembership({
+                        user: userC, mship: "join",
+                        room: roomId, event: true, name: "User C",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true, user: userA,
+                        content: {
+                            service_members: [userC],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+
+            it("should return 'Empty room' if all other members are functional members",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkMembership({
+                        user: userC, mship: "join",
+                        room: roomId, event: true, name: "User C",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true, user: userA,
+                        content: {
+                            service_members: [userB, userC],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("Empty room");
+            });
+
+            it("should not break if an unjoined user is marked as a service user",
+            function() {
+                const room = new Room(roomId, null, userA);
+                room.addLiveEvents([
+                    utils.mkMembership({
+                        user: userA, mship: "join",
+                        room: roomId, event: true, name: "User A",
+                    }),
+                    utils.mkMembership({
+                        user: userB, mship: "join",
+                        room: roomId, event: true, name: "User B",
+                    }),
+                    utils.mkEvent({
+                        type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
+                        room: roomId, event: true, user: userA,
+                        content: {
+                            service_members: [userC],
+                        },
+                    }),
+                ]);
+                expect(room.getDefaultRoomName(userA)).toEqual("User B");
+            });
+        });
+    });
 });

spec/unit/scheduler.spec.js

@@ -1,9 +1,9 @@
 // This file had a function whose name is all caps, which displeases eslint
 /* eslint new-cap: "off" */
 
-import {defer} from '../../src/utils';
-import {MatrixError} from "../../src/http-api";
-import {MatrixScheduler} from "../../src/scheduler";
+import { defer } from '../../src/utils';
+import { MatrixError } from "../../src/http-api";
+import { MatrixScheduler } from "../../src/scheduler";
 import * as utils from "../test-utils";
 
 jest.useFakeTimers();
@@ -62,8 +62,8 @@ describe("MatrixScheduler", function() {
             scheduler.queueEvent(eventA),
             scheduler.queueEvent(eventB),
         ]);
-        deferB.resolve({b: true});
-        deferA.resolve({a: true});
+        deferB.resolve({ b: true });
+        deferA.resolve({ a: true });
         const [a, b] = await abPromise;
         expect(a.a).toEqual(true);
         expect(b.b).toEqual(true);
@@ -143,7 +143,7 @@ describe("MatrixScheduler", function() {
         deferA.reject({});
         try {
             await globalA;
-        } catch(err) {
+        } catch (err) {
             await Promise.resolve();
             expect(procCount).toEqual(2);
         }
@@ -156,8 +156,8 @@ describe("MatrixScheduler", function() {
         // Expect to have processFn invoked for A&B.
         // Resolve A.
         // Expect to have processFn invoked for D.
-        const eventC = utils.mkMessage({user: "@a:bar", room: roomId, event: true});
-        const eventD = utils.mkMessage({user: "@b:bar", room: roomId, event: true});
+        const eventC = utils.mkMessage({ user: "@a:bar", room: roomId, event: true });
+        const eventD = utils.mkMessage({ user: "@b:bar", room: roomId, event: true });
 
         const buckets = {};
         buckets[eventA.getId()] = "queue_A";
@@ -241,7 +241,7 @@ describe("MatrixScheduler", function() {
             expect(queue).toEqual([eventA, eventB]);
             // modify the queue
             const eventC = utils.mkMessage(
-                {user: "@a:bar", room: roomId, event: true},
+                { user: "@a:bar", room: roomId, event: true },
             );
             queue.push(eventC);
             const queueAgain = scheduler.getQueueForEvent(eventA);

spec/unit/sync-accumulator.spec.js

@@ -15,7 +15,40 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {SyncAccumulator} from "../../src/sync-accumulator";
+import { SyncAccumulator } from "../../src/sync-accumulator";
+
+// The event body & unsigned object get frozen to assert that they don't get altered
+// by the impl
+const RES_WITH_AGE = {
+    next_batch: "abc",
+    rooms: {
+        invite: {},
+        leave: {},
+        join: {
+            "!foo:bar": {
+                account_data: { events: [] },
+                ephemeral: { events: [] },
+                unread_notifications: {},
+                timeline: {
+                    events: [
+                        Object.freeze({
+                            content: {
+                                body: "This thing is happening right now!",
+                            },
+                            origin_server_ts: 123456789,
+                            sender: "@alice:localhost",
+                            type: "m.room.message",
+                            unsigned: Object.freeze({
+                                age: 50,
+                            }),
+                        }),
+                    ],
+                    prev_batch: "something",
+                },
+            },
+        },
+    },
+};
 
 describe("SyncAccumulator", function() {
     let sa;
@@ -368,6 +401,39 @@ describe("SyncAccumulator", function() {
             expect(summary["m.joined_member_count"]).toEqual(5);
             expect(summary["m.heroes"]).toEqual(["@bob:bar"]);
         });
+
+        it("should return correctly adjusted age attributes", () => {
+            const delta = 1000;
+            const startingTs = 1000;
+
+            const oldDateNow = Date.now;
+            try {
+                Date.now = jest.fn();
+                Date.now.mockReturnValue(startingTs);
+
+                sa.accumulate(RES_WITH_AGE);
+
+                Date.now.mockReturnValue(startingTs + delta);
+
+                const output = sa.getJSON();
+                expect(output.roomsData.join["!foo:bar"].timeline.events[0].unsigned.age).toEqual(
+                    RES_WITH_AGE.rooms.join["!foo:bar"].timeline.events[0].unsigned.age + delta,
+                );
+                expect(Object.keys(output.roomsData.join["!foo:bar"].timeline.events[0])).toEqual(
+                    Object.keys(RES_WITH_AGE.rooms.join["!foo:bar"].timeline.events[0]),
+                );
+            } finally {
+                Date.now = oldDateNow;
+            }
+        });
+
+        it("should mangle age without adding extra keys", () => {
+            sa.accumulate(RES_WITH_AGE);
+            const output = sa.getJSON();
+            expect(Object.keys(output.roomsData.join["!foo:bar"].timeline.events[0])).toEqual(
+                Object.keys(RES_WITH_AGE.rooms.join["!foo:bar"].timeline.events[0]),
+            );
+        });
     });
 });
 

spec/unit/timeline-window.spec.js

@@ -1,5 +1,5 @@
-import {EventTimeline} from "../../src/models/event-timeline";
-import {TimelineIndex, TimelineWindow} from "../../src/timeline-window";
+import { EventTimeline } from "../../src/models/event-timeline";
+import { TimelineIndex, TimelineWindow } from "../../src/timeline-window";
 import * as utils from "../test-utils";
 
 const ROOM_ID = "roomId";
@@ -18,7 +18,7 @@ function createTimeline(numEvents, baseIndex) {
     }
 
     // XXX: this is a horrid hack
-    const timelineSet = { room: { roomId: ROOM_ID }};
+    const timelineSet = { room: { roomId: ROOM_ID } };
     timelineSet.room.getUnfilteredTimelineSet = function() {
         return timelineSet;
     };
@@ -46,7 +46,6 @@ function addEventsToTimeline(timeline, numEvents, atStart) {
     }
 }
 
-
 /*
  * create a pair of linked timelines
  */
@@ -58,7 +57,6 @@ function createLinkedTimelines() {
     return [tl1, tl2];
 }
 
-
 describe("TimelineIndex", function() {
     describe("minIndex", function() {
         it("should return the min index relative to BaseIndex", function() {
@@ -133,7 +131,6 @@ describe("TimelineIndex", function() {
     });
 });
 
-
 describe("TimelineWindow", function() {
     /**
      * create a dummy eventTimelineSet and client, and a TimelineWindow
@@ -142,7 +139,7 @@ describe("TimelineWindow", function() {
     let timelineSet;
     let client;
     function createWindow(timeline, opts) {
-        timelineSet = {getTimelineForEvent: () => null};
+        timelineSet = { getTimelineForEvent: () => null };
         client = {};
         client.getEventTimeline = function(timelineSet0, eventId0) {
             expect(timelineSet0).toBe(timelineSet);
@@ -171,7 +168,7 @@ describe("TimelineWindow", function() {
             const timeline = createTimeline();
             const eventId = timeline.getEvents()[1].getId();
 
-            const timelineSet = {getTimelineForEvent: () => null};
+            const timelineSet = { getTimelineForEvent: () => null };
             const client = {};
             client.getEventTimeline = function(timelineSet0, eventId0) {
                 expect(timelineSet0).toBe(timelineSet);
@@ -193,7 +190,7 @@ describe("TimelineWindow", function() {
 
             const eventId = timeline.getEvents()[1].getId();
 
-            const timelineSet = {getTimelineForEvent: () => null};
+            const timelineSet = { getTimelineForEvent: () => null };
             const client = {};
 
             const timelineWindow = new TimelineWindow(client, timelineSet);
@@ -266,7 +263,7 @@ describe("TimelineWindow", function() {
         it("should advance into next timeline", function() {
             const tls = createLinkedTimelines();
             const eventId = tls[0].getEvents()[1].getId();
-            const timelineWindow = createWindow(tls[0], {windowLimit: 5});
+            const timelineWindow = createWindow(tls[0], { windowLimit: 5 });
 
             return timelineWindow.load(eventId, 3).then(function() {
                 const expectedEvents = tls[0].getEvents();
@@ -311,7 +308,7 @@ describe("TimelineWindow", function() {
         it("should retreat into previous timeline", function() {
             const tls = createLinkedTimelines();
             const eventId = tls[1].getEvents()[1].getId();
-            const timelineWindow = createWindow(tls[1], {windowLimit: 5});
+            const timelineWindow = createWindow(tls[1], { windowLimit: 5 });
 
             return timelineWindow.load(eventId, 3).then(function() {
                 const expectedEvents = tls[1].getEvents();
@@ -357,7 +354,7 @@ describe("TimelineWindow", function() {
             const timeline = createTimeline();
             timeline.setPaginationToken("toktok", EventTimeline.FORWARDS);
 
-            const timelineWindow = createWindow(timeline, {windowLimit: 5});
+            const timelineWindow = createWindow(timeline, { windowLimit: 5 });
             const eventId = timeline.getEvents()[1].getId();
 
             client.paginateEventTimeline = function(timeline0, opts) {
@@ -385,12 +382,11 @@ describe("TimelineWindow", function() {
             });
         });
 
-
         it("should make backward pagination requests", function() {
             const timeline = createTimeline();
             timeline.setPaginationToken("toktok", EventTimeline.BACKWARDS);
 
-            const timelineWindow = createWindow(timeline, {windowLimit: 5});
+            const timelineWindow = createWindow(timeline, { windowLimit: 5 });
             const eventId = timeline.getEvents()[1].getId();
 
             client.paginateEventTimeline = function(timeline0, opts) {
@@ -422,7 +418,7 @@ describe("TimelineWindow", function() {
             const timeline = createTimeline();
             timeline.setPaginationToken("toktok", EventTimeline.FORWARDS);
 
-            const timelineWindow = createWindow(timeline, {windowLimit: 5});
+            const timelineWindow = createWindow(timeline, { windowLimit: 5 });
             const eventId = timeline.getEvents()[1].getId();
 
             let paginateCount = 0;

spec/unit/user.spec.js

@@ -1,4 +1,4 @@
-import {User} from "../../src/models/user";
+import { User } from "../../src/models/user";
 import * as utils from "../test-utils";
 
 describe("User", function() {

spec/unit/utils.spec.js

@@ -1,285 +0,0 @@
-import * as utils from "../../src/utils";
-
-describe("utils", function() {
-    describe("encodeParams", function() {
-        it("should url encode and concat with &s", function() {
-            const params = {
-                foo: "bar",
-                baz: "beer@",
-            };
-            expect(utils.encodeParams(params)).toEqual(
-                "foo=bar&baz=beer%40",
-            );
-        });
-    });
-
-    describe("encodeUri", function() {
-        it("should replace based on object keys and url encode", function() {
-            const path = "foo/bar/%something/%here";
-            const vals = {
-                "%something": "baz",
-                "%here": "beer@",
-            };
-            expect(utils.encodeUri(path, vals)).toEqual(
-                "foo/bar/baz/beer%40",
-            );
-        });
-    });
-
-    describe("forEach", function() {
-        it("should be invoked for each element", function() {
-            const arr = [];
-            utils.forEach([55, 66, 77], function(element) {
-                arr.push(element);
-            });
-            expect(arr).toEqual([55, 66, 77]);
-        });
-    });
-
-    describe("findElement", function() {
-        it("should find only 1 element if there is a match", function() {
-            const matchFn = function() {
-                return true;
-            };
-            const arr = [55, 66, 77];
-            expect(utils.findElement(arr, matchFn)).toEqual(55);
-        });
-        it("should be able to find in reverse order", function() {
-            const matchFn = function() {
-                return true;
-            };
-            const arr = [55, 66, 77];
-            expect(utils.findElement(arr, matchFn, true)).toEqual(77);
-        });
-        it("should find nothing if the function never returns true", function() {
-            const matchFn = function() {
-                return false;
-            };
-            const arr = [55, 66, 77];
-            expect(utils.findElement(arr, matchFn)).toBeFalsy();
-        });
-    });
-
-    describe("removeElement", function() {
-        it("should remove only 1 element if there is a match", function() {
-            const matchFn = function() {
-                return true;
-            };
-            const arr = [55, 66, 77];
-            utils.removeElement(arr, matchFn);
-            expect(arr).toEqual([66, 77]);
-        });
-        it("should be able to remove in reverse order", function() {
-            const matchFn = function() {
-                return true;
-            };
-            const arr = [55, 66, 77];
-            utils.removeElement(arr, matchFn, true);
-            expect(arr).toEqual([55, 66]);
-        });
-        it("should remove nothing if the function never returns true", function() {
-            const matchFn = function() {
-                return false;
-            };
-            const arr = [55, 66, 77];
-            utils.removeElement(arr, matchFn);
-            expect(arr).toEqual(arr);
-        });
-    });
-
-    describe("isFunction", function() {
-        it("should return true for functions", function() {
-            expect(utils.isFunction([])).toBe(false);
-            expect(utils.isFunction([5, 3, 7])).toBe(false);
-            expect(utils.isFunction()).toBe(false);
-            expect(utils.isFunction(null)).toBe(false);
-            expect(utils.isFunction({})).toBe(false);
-            expect(utils.isFunction("foo")).toBe(false);
-            expect(utils.isFunction(555)).toBe(false);
-
-            expect(utils.isFunction(function() {})).toBe(true);
-            const s = { foo: function() {} };
-            expect(utils.isFunction(s.foo)).toBe(true);
-        });
-    });
-
-    describe("isArray", function() {
-        it("should return true for arrays", function() {
-            expect(utils.isArray([])).toBe(true);
-            expect(utils.isArray([5, 3, 7])).toBe(true);
-
-            expect(utils.isArray()).toBe(false);
-            expect(utils.isArray(null)).toBe(false);
-            expect(utils.isArray({})).toBe(false);
-            expect(utils.isArray("foo")).toBe(false);
-            expect(utils.isArray(555)).toBe(false);
-            expect(utils.isArray(function() {})).toBe(false);
-        });
-    });
-
-    describe("checkObjectHasKeys", function() {
-        it("should throw for missing keys", function() {
-            expect(function() {
-                utils.checkObjectHasKeys({}, ["foo"]);
-            }).toThrow();
-            expect(function() {
-                utils.checkObjectHasKeys({
-                    foo: "bar",
-                }, ["foo"]);
-            }).not.toThrow();
-        });
-    });
-
-    describe("checkObjectHasNoAdditionalKeys", function() {
-        it("should throw for extra keys", function() {
-            expect(function() {
-                utils.checkObjectHasNoAdditionalKeys({
-                            foo: "bar",
-                            baz: 4,
-                        }, ["foo"]);
-            }).toThrow();
-
-            expect(function() {
-                utils.checkObjectHasNoAdditionalKeys({
-                            foo: "bar",
-                        }, ["foo"]);
-            }).not.toThrow();
-        });
-    });
-
-    describe("deepCompare", function() {
-        const assert = {
-            isTrue: function(x) {
-                expect(x).toBe(true);
-            },
-            isFalse: function(x) {
-                expect(x).toBe(false);
-            },
-        };
-
-        it("should handle primitives", function() {
-            assert.isTrue(utils.deepCompare(null, null));
-            assert.isFalse(utils.deepCompare(null, undefined));
-            assert.isTrue(utils.deepCompare("hi", "hi"));
-            assert.isTrue(utils.deepCompare(5, 5));
-            assert.isFalse(utils.deepCompare(5, 10));
-        });
-
-        it("should handle regexps", function() {
-            assert.isTrue(utils.deepCompare(/abc/, /abc/));
-            assert.isFalse(utils.deepCompare(/abc/, /123/));
-            const r = /abc/;
-            assert.isTrue(utils.deepCompare(r, r));
-        });
-
-        it("should handle dates", function() {
-            assert.isTrue(utils.deepCompare(new Date("2011-03-31"),
-                                            new Date("2011-03-31")));
-            assert.isFalse(utils.deepCompare(new Date("2011-03-31"),
-                                             new Date("1970-01-01")));
-        });
-
-        it("should handle arrays", function() {
-            assert.isTrue(utils.deepCompare([], []));
-            assert.isTrue(utils.deepCompare([1, 2], [1, 2]));
-            assert.isFalse(utils.deepCompare([1, 2], [2, 1]));
-            assert.isFalse(utils.deepCompare([1, 2], [1, 2, 3]));
-        });
-
-        it("should handle simple objects", function() {
-            assert.isTrue(utils.deepCompare({}, {}));
-            assert.isTrue(utils.deepCompare({a: 1, b: 2}, {a: 1, b: 2}));
-            assert.isTrue(utils.deepCompare({a: 1, b: 2}, {b: 2, a: 1}));
-            assert.isFalse(utils.deepCompare({a: 1, b: 2}, {a: 1, b: 3}));
-
-            assert.isTrue(utils.deepCompare({1: {name: "mhc", age: 28},
-                                             2: {name: "arb", age: 26}},
-                                            {1: {name: "mhc", age: 28},
-                                             2: {name: "arb", age: 26}}));
-
-            assert.isFalse(utils.deepCompare({1: {name: "mhc", age: 28},
-                                              2: {name: "arb", age: 26}},
-                                             {1: {name: "mhc", age: 28},
-                                              2: {name: "arb", age: 27}}));
-
-            assert.isFalse(utils.deepCompare({}, null));
-            assert.isFalse(utils.deepCompare({}, undefined));
-        });
-
-        it("should handle functions", function() {
-            // no two different function is equal really, they capture their
-            // context variables so even if they have same toString(), they
-            // won't have same functionality
-            const func = function(x) {
-                return true;
-            };
-            const func2 = function(x) {
-                return true;
-            };
-            assert.isTrue(utils.deepCompare(func, func));
-            assert.isFalse(utils.deepCompare(func, func2));
-            assert.isTrue(utils.deepCompare({ a: { b: func } }, { a: { b: func } }));
-            assert.isFalse(utils.deepCompare({ a: { b: func } }, { a: { b: func2 } }));
-        });
-    });
-
-
-    describe("extend", function() {
-        const SOURCE = { "prop2": 1, "string2": "x", "newprop": "new" };
-
-        it("should extend", function() {
-            const target = {
-                "prop1": 5, "prop2": 7, "string1": "baz", "string2": "foo",
-            };
-            const merged = {
-                "prop1": 5, "prop2": 1, "string1": "baz", "string2": "x",
-                "newprop": "new",
-            };
-            const sourceOrig = JSON.stringify(SOURCE);
-
-            utils.extend(target, SOURCE);
-            expect(JSON.stringify(target)).toEqual(JSON.stringify(merged));
-
-            // check the originial wasn't modified
-            expect(JSON.stringify(SOURCE)).toEqual(sourceOrig);
-        });
-
-        it("should ignore null", function() {
-            const target = {
-                "prop1": 5, "prop2": 7, "string1": "baz", "string2": "foo",
-            };
-            const merged = {
-                "prop1": 5, "prop2": 1, "string1": "baz", "string2": "x",
-                "newprop": "new",
-            };
-            const sourceOrig = JSON.stringify(SOURCE);
-
-            utils.extend(target, null, SOURCE);
-            expect(JSON.stringify(target)).toEqual(JSON.stringify(merged));
-
-            // check the originial wasn't modified
-            expect(JSON.stringify(SOURCE)).toEqual(sourceOrig);
-        });
-
-        it("should handle properties created with defineProperties", function() {
-            const source = Object.defineProperties({}, {
-                "enumerableProp": {
-                    get: function() {
-                        return true;
-                    },
-                    enumerable: true,
-                },
-                "nonenumerableProp": {
-                    get: function() {
-                        return true;
-                    },
-                },
-            });
-
-            const target = {};
-            utils.extend(target, source);
-            expect(target.enumerableProp).toBe(true);
-            expect(target.nonenumerableProp).toBe(undefined);
-        });
-    });
-});

spec/unit/utils.spec.ts

@@ -0,0 +1,560 @@
+import * as utils from "../../src/utils";
+import {
+    alphabetPad,
+    averageBetweenStrings,
+    baseToString,
+    deepSortedObjectEntries,
+    DEFAULT_ALPHABET,
+    lexicographicCompare,
+    nextString,
+    prevString,
+    simpleRetryOperation,
+    stringToBase,
+} from "../../src/utils";
+import { logger } from "../../src/logger";
+
+// TODO: Fix types throughout
+
+describe("utils", function() {
+    describe("encodeParams", function() {
+        it("should url encode and concat with &s", function() {
+            const params = {
+                foo: "bar",
+                baz: "beer@",
+            };
+            expect(utils.encodeParams(params)).toEqual(
+                "foo=bar&baz=beer%40",
+            );
+        });
+    });
+
+    describe("encodeUri", function() {
+        it("should replace based on object keys and url encode", function() {
+            const path = "foo/bar/%something/%here";
+            const vals = {
+                "%something": "baz",
+                "%here": "beer@",
+            };
+            expect(utils.encodeUri(path, vals)).toEqual(
+                "foo/bar/baz/beer%40",
+            );
+        });
+    });
+
+    describe("removeElement", function() {
+        it("should remove only 1 element if there is a match", function() {
+            const matchFn = function() {
+                return true;
+            };
+            const arr = [55, 66, 77];
+            utils.removeElement(arr, matchFn);
+            expect(arr).toEqual([66, 77]);
+        });
+        it("should be able to remove in reverse order", function() {
+            const matchFn = function() {
+                return true;
+            };
+            const arr = [55, 66, 77];
+            utils.removeElement(arr, matchFn, true);
+            expect(arr).toEqual([55, 66]);
+        });
+        it("should remove nothing if the function never returns true", function() {
+            const matchFn = function() {
+                return false;
+            };
+            const arr = [55, 66, 77];
+            utils.removeElement(arr, matchFn);
+            expect(arr).toEqual(arr);
+        });
+    });
+
+    describe("isFunction", function() {
+        it("should return true for functions", function() {
+            expect(utils.isFunction([])).toBe(false);
+            expect(utils.isFunction([5, 3, 7])).toBe(false);
+            expect(utils.isFunction(undefined)).toBe(false);
+            expect(utils.isFunction(null)).toBe(false);
+            expect(utils.isFunction({})).toBe(false);
+            expect(utils.isFunction("foo")).toBe(false);
+            expect(utils.isFunction(555)).toBe(false);
+
+            expect(utils.isFunction(function() {})).toBe(true);
+            const s = { foo: function() {} };
+            expect(utils.isFunction(s.foo)).toBe(true);
+        });
+    });
+
+    describe("checkObjectHasKeys", function() {
+        it("should throw for missing keys", function() {
+            expect(function() {
+                utils.checkObjectHasKeys({}, ["foo"]);
+            }).toThrow();
+            expect(function() {
+                utils.checkObjectHasKeys({
+                    foo: "bar",
+                }, ["foo"]);
+            }).not.toThrow();
+        });
+    });
+
+    describe("checkObjectHasNoAdditionalKeys", function() {
+        it("should throw for extra keys", function() {
+            expect(function() {
+                utils.checkObjectHasNoAdditionalKeys({ foo: "bar", baz: 4 }, ["foo"]);
+            }).toThrow();
+
+            expect(function() {
+                utils.checkObjectHasNoAdditionalKeys({ foo: "bar" }, ["foo"]);
+            }).not.toThrow();
+        });
+    });
+
+    describe("deepCompare", function() {
+        const assert = {
+            isTrue: function(x) {
+                expect(x).toBe(true);
+            },
+            isFalse: function(x) {
+                expect(x).toBe(false);
+            },
+        };
+
+        it("should handle primitives", function() {
+            assert.isTrue(utils.deepCompare(null, null));
+            assert.isFalse(utils.deepCompare(null, undefined));
+            assert.isTrue(utils.deepCompare("hi", "hi"));
+            assert.isTrue(utils.deepCompare(5, 5));
+            assert.isFalse(utils.deepCompare(5, 10));
+        });
+
+        it("should handle regexps", function() {
+            assert.isTrue(utils.deepCompare(/abc/, /abc/));
+            assert.isFalse(utils.deepCompare(/abc/, /123/));
+            const r = /abc/;
+            assert.isTrue(utils.deepCompare(r, r));
+        });
+
+        it("should handle dates", function() {
+            assert.isTrue(utils.deepCompare(new Date("2011-03-31"), new Date("2011-03-31")));
+            assert.isFalse(utils.deepCompare(new Date("2011-03-31"), new Date("1970-01-01")));
+        });
+
+        it("should handle arrays", function() {
+            assert.isTrue(utils.deepCompare([], []));
+            assert.isTrue(utils.deepCompare([1, 2], [1, 2]));
+            assert.isFalse(utils.deepCompare([1, 2], [2, 1]));
+            assert.isFalse(utils.deepCompare([1, 2], [1, 2, 3]));
+        });
+
+        it("should handle simple objects", function() {
+            assert.isTrue(utils.deepCompare({}, {}));
+            assert.isTrue(utils.deepCompare({ a: 1, b: 2 }, { a: 1, b: 2 }));
+            assert.isTrue(utils.deepCompare({ a: 1, b: 2 }, { b: 2, a: 1 }));
+            assert.isFalse(utils.deepCompare({ a: 1, b: 2 }, { a: 1, b: 3 }));
+
+            assert.isTrue(utils.deepCompare({
+                1: { name: "mhc", age: 28 },
+                2: { name: "arb", age: 26 },
+            }, {
+                1: { name: "mhc", age: 28 },
+                2: { name: "arb", age: 26 },
+            }));
+
+            assert.isFalse(utils.deepCompare({
+                1: { name: "mhc", age: 28 },
+                2: { name: "arb", age: 26 },
+            }, {
+                1: { name: "mhc", age: 28 },
+                2: { name: "arb", age: 27 },
+            }));
+
+            assert.isFalse(utils.deepCompare({}, null));
+            assert.isFalse(utils.deepCompare({}, undefined));
+        });
+
+        it("should handle functions", function() {
+            // no two different function is equal really, they capture their
+            // context variables so even if they have same toString(), they
+            // won't have same functionality
+            const func = function(x) {
+                return true;
+            };
+            const func2 = function(x) {
+                return true;
+            };
+            assert.isTrue(utils.deepCompare(func, func));
+            assert.isFalse(utils.deepCompare(func, func2));
+            assert.isTrue(utils.deepCompare({ a: { b: func } }, { a: { b: func } }));
+            assert.isFalse(utils.deepCompare({ a: { b: func } }, { a: { b: func2 } }));
+        });
+    });
+
+    describe("extend", function() {
+        const SOURCE = { "prop2": 1, "string2": "x", "newprop": "new" };
+
+        it("should extend", function() {
+            const target = {
+                "prop1": 5, "prop2": 7, "string1": "baz", "string2": "foo",
+            };
+            const merged = {
+                "prop1": 5, "prop2": 1, "string1": "baz", "string2": "x",
+                "newprop": "new",
+            };
+            const sourceOrig = JSON.stringify(SOURCE);
+
+            utils.extend(target, SOURCE);
+            expect(JSON.stringify(target)).toEqual(JSON.stringify(merged));
+
+            // check the originial wasn't modified
+            expect(JSON.stringify(SOURCE)).toEqual(sourceOrig);
+        });
+
+        it("should ignore null", function() {
+            const target = {
+                "prop1": 5, "prop2": 7, "string1": "baz", "string2": "foo",
+            };
+            const merged = {
+                "prop1": 5, "prop2": 1, "string1": "baz", "string2": "x",
+                "newprop": "new",
+            };
+            const sourceOrig = JSON.stringify(SOURCE);
+
+            utils.extend(target, null, SOURCE);
+            expect(JSON.stringify(target)).toEqual(JSON.stringify(merged));
+
+            // check the originial wasn't modified
+            expect(JSON.stringify(SOURCE)).toEqual(sourceOrig);
+        });
+
+        it("should handle properties created with defineProperties", function() {
+            const source = Object.defineProperties({}, {
+                "enumerableProp": {
+                    get: function() {
+                        return true;
+                    },
+                    enumerable: true,
+                },
+                "nonenumerableProp": {
+                    get: function() {
+                        return true;
+                    },
+                },
+            });
+
+            // TODO: Fix type
+            const target: any = {};
+            utils.extend(target, source);
+            expect(target.enumerableProp).toBe(true);
+            expect(target.nonenumerableProp).toBe(undefined);
+        });
+    });
+
+    describe("chunkPromises", function() {
+        it("should execute promises in chunks", async function() {
+            let promiseCount = 0;
+
+            async function fn1() {
+                await utils.sleep(1);
+                expect(promiseCount).toEqual(0);
+                ++promiseCount;
+            }
+
+            async function fn2() {
+                expect(promiseCount).toEqual(1);
+                ++promiseCount;
+            }
+
+            await utils.chunkPromises([fn1, fn2], 1);
+            expect(promiseCount).toEqual(2);
+        });
+    });
+
+    describe('simpleRetryOperation', () => {
+        it('should retry', async () => {
+            let count = 0;
+            const val = {};
+            const fn = (attempt) => {
+                count++;
+
+                // If this expectation fails then it can appear as a Jest Timeout due to
+                // the retry running beyond the test limit.
+                expect(attempt).toEqual(count);
+
+                if (count > 1) {
+                    return Promise.resolve(val);
+                } else {
+                    return Promise.reject(new Error("Iterative failure"));
+                }
+            };
+
+            const ret = await simpleRetryOperation(fn);
+            expect(ret).toBe(val);
+            expect(count).toEqual(2);
+        });
+
+        // We don't test much else of the function because then we're just testing that the
+        // underlying library behaves, which should be tested on its own. Our API surface is
+        // all that concerns us.
+    });
+
+    describe('DEFAULT_ALPHABET', () => {
+        it('should be usefully printable ASCII in order', () => {
+            expect(DEFAULT_ALPHABET).toEqual(
+                " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
+            );
+        });
+    });
+
+    describe('alphabetPad', () => {
+        it('should pad to the alphabet length', () => {
+            const len = 12;
+            expect(alphabetPad("a", len)).toEqual("a" + ("".padEnd(len - 1, DEFAULT_ALPHABET[0])));
+            expect(alphabetPad("a", len, "123")).toEqual("a" + ("".padEnd(len - 1, '1')));
+        });
+    });
+
+    describe('baseToString', () => {
+        it('should calculate the appropriate string from numbers', () => {
+            // Verify the whole alphabet
+            for (let i = BigInt(1); i <= DEFAULT_ALPHABET.length; i++) {
+                logger.log({ i }); // for debugging
+                expect(baseToString(i)).toEqual(DEFAULT_ALPHABET[Number(i) - 1]);
+            }
+
+            // Just quickly double check that repeated characters aren't treated as padding, particularly
+            // at the beginning of the alphabet where they are most vulnerable to this behaviour.
+            expect(baseToString(BigInt(1))).toEqual(DEFAULT_ALPHABET[0].repeat(1));
+            expect(baseToString(BigInt(96))).toEqual(DEFAULT_ALPHABET[0].repeat(2));
+            expect(baseToString(BigInt(9121))).toEqual(DEFAULT_ALPHABET[0].repeat(3));
+            expect(baseToString(BigInt(866496))).toEqual(DEFAULT_ALPHABET[0].repeat(4));
+            expect(baseToString(BigInt(82317121))).toEqual(DEFAULT_ALPHABET[0].repeat(5));
+            expect(baseToString(BigInt(7820126496))).toEqual(DEFAULT_ALPHABET[0].repeat(6));
+
+            expect(baseToString(BigInt(10))).toEqual(DEFAULT_ALPHABET[9]);
+            expect(baseToString(BigInt(10), "abcdefghijklmnopqrstuvwxyz")).toEqual('j');
+            expect(baseToString(BigInt(6337))).toEqual("ab");
+            expect(baseToString(BigInt(80), "abcdefghijklmnopqrstuvwxyz")).toEqual('cb');
+        });
+    });
+
+    describe('stringToBase', () => {
+        it('should calculate the appropriate number for a string', () => {
+            expect(stringToBase(DEFAULT_ALPHABET[0].repeat(1))).toEqual(BigInt(1));
+            expect(stringToBase(DEFAULT_ALPHABET[0].repeat(2))).toEqual(BigInt(96));
+            expect(stringToBase(DEFAULT_ALPHABET[0].repeat(3))).toEqual(BigInt(9121));
+            expect(stringToBase(DEFAULT_ALPHABET[0].repeat(4))).toEqual(BigInt(866496));
+            expect(stringToBase(DEFAULT_ALPHABET[0].repeat(5))).toEqual(BigInt(82317121));
+            expect(stringToBase(DEFAULT_ALPHABET[0].repeat(6))).toEqual(BigInt(7820126496));
+            expect(stringToBase("a", "abcdefghijklmnopqrstuvwxyz")).toEqual(BigInt(1));
+            expect(stringToBase("a")).toEqual(BigInt(66));
+            expect(stringToBase("c", "abcdefghijklmnopqrstuvwxyz")).toEqual(BigInt(3));
+            expect(stringToBase("ab")).toEqual(BigInt(6337));
+            expect(stringToBase("cb", "abcdefghijklmnopqrstuvwxyz")).toEqual(BigInt(80));
+        });
+    });
+
+    describe('averageBetweenStrings', () => {
+        it('should average appropriately', () => {
+            expect(averageBetweenStrings("  ", "!!")).toEqual(" P");
+            expect(averageBetweenStrings(" ", "!")).toEqual("  ");
+            expect(averageBetweenStrings('A', 'B')).toEqual('A ');
+            expect(averageBetweenStrings('AA', 'BB')).toEqual('Aq');
+            expect(averageBetweenStrings('A', 'z')).toEqual(']');
+            expect(averageBetweenStrings('a', 'z', "abcdefghijklmnopqrstuvwxyz")).toEqual('m');
+            expect(averageBetweenStrings('AA', 'zz')).toEqual('^.');
+            expect(averageBetweenStrings('aa', 'zz', "abcdefghijklmnopqrstuvwxyz")).toEqual('mz');
+            expect(averageBetweenStrings('cat', 'doggo')).toEqual("d9>Cw");
+            expect(averageBetweenStrings('cat', 'doggo', "abcdefghijklmnopqrstuvwxyz")).toEqual("cumqh");
+        });
+    });
+
+    describe('nextString', () => {
+        it('should find the next string appropriately', () => {
+            expect(nextString('A')).toEqual('B');
+            expect(nextString('b', 'abcdefghijklmnopqrstuvwxyz')).toEqual('c');
+            expect(nextString('cat')).toEqual('cau');
+            expect(nextString('cat', 'abcdefghijklmnopqrstuvwxyz')).toEqual('cau');
+        });
+    });
+
+    describe('prevString', () => {
+        it('should find the next string appropriately', () => {
+            expect(prevString('B')).toEqual('A');
+            expect(prevString('c', 'abcdefghijklmnopqrstuvwxyz')).toEqual('b');
+            expect(prevString('cau')).toEqual('cat');
+            expect(prevString('cau', 'abcdefghijklmnopqrstuvwxyz')).toEqual('cat');
+        });
+    });
+
+    // Let's just ensure the ordering is sensible for lexicographic ordering
+    describe('string averaging unified', () => {
+        it('should be truly previous and next', () => {
+            let midpoint = "cat";
+
+            // We run this test 100 times to ensure we end up with a sane sequence.
+            for (let i = 0; i < 100; i++) {
+                const next = nextString(midpoint);
+                const prev = prevString(midpoint);
+                logger.log({ i, midpoint, next, prev }); // for test debugging
+
+                expect(lexicographicCompare(midpoint, next) < 0).toBe(true);
+                expect(lexicographicCompare(midpoint, prev) > 0).toBe(true);
+                expect(averageBetweenStrings(prev, next)).toBe(midpoint);
+
+                midpoint = next;
+            }
+        });
+
+        it('should roll over', () => {
+            const lastAlpha = DEFAULT_ALPHABET[DEFAULT_ALPHABET.length - 1];
+            const firstAlpha = DEFAULT_ALPHABET[0];
+
+            const highRoll = firstAlpha + firstAlpha;
+            const lowRoll = lastAlpha;
+
+            expect(nextString(lowRoll)).toEqual(highRoll);
+            expect(prevString(highRoll)).toEqual(lowRoll);
+        });
+
+        it('should be reversible on small strings', () => {
+            // Large scale reversibility is tested for max space order value
+            const input = "cats";
+            expect(prevString(nextString(input))).toEqual(input);
+        });
+
+        // We want to explicitly make sure that Space order values are supported and roll appropriately
+        it('should properly handle rolling over at 50 characters', () => {
+            // Note: we also test reversibility of large strings here.
+
+            const maxSpaceValue = DEFAULT_ALPHABET[DEFAULT_ALPHABET.length - 1].repeat(50);
+            const fiftyFirstChar = DEFAULT_ALPHABET[0].repeat(51);
+
+            expect(nextString(maxSpaceValue)).toBe(fiftyFirstChar);
+            expect(prevString(fiftyFirstChar)).toBe(maxSpaceValue);
+
+            // We're testing that the rollover happened, which means that the next string come before
+            // the maximum space order value lexicographically.
+            expect(lexicographicCompare(maxSpaceValue, fiftyFirstChar) > 0).toBe(true);
+        });
+    });
+
+    describe('lexicographicCompare', () => {
+        it('should work', () => {
+            // Simple tests
+            expect(lexicographicCompare('a', 'b') < 0).toBe(true);
+            expect(lexicographicCompare('ab', 'b') < 0).toBe(true);
+            expect(lexicographicCompare('cat', 'dog') < 0).toBe(true);
+
+            // Simple tests (reversed)
+            expect(lexicographicCompare('b', 'a') > 0).toBe(true);
+            expect(lexicographicCompare('b', 'ab') > 0).toBe(true);
+            expect(lexicographicCompare('dog', 'cat') > 0).toBe(true);
+
+            // Simple equality tests
+            expect(lexicographicCompare('a', 'a') === 0).toBe(true);
+            expect(lexicographicCompare('A', 'A') === 0).toBe(true);
+
+            // ASCII rule testing
+            expect(lexicographicCompare('A', 'a') < 0).toBe(true);
+            expect(lexicographicCompare('a', 'A') > 0).toBe(true);
+        });
+    });
+
+    describe('deepSortedObjectEntries', () => {
+        it('should auto-return non-objects', () => {
+            expect(deepSortedObjectEntries(42)).toEqual(42);
+            expect(deepSortedObjectEntries("not object")).toEqual("not object");
+            expect(deepSortedObjectEntries(true)).toEqual(true);
+            expect(deepSortedObjectEntries([42])).toEqual([42]);
+            expect(deepSortedObjectEntries(null)).toEqual(null);
+            expect(deepSortedObjectEntries(undefined)).toEqual(undefined);
+        });
+
+        it('should sort objects appropriately', () => {
+            const input = {
+                a: 42,
+                b: {
+                    d: {},
+                    a: "test",
+                    b: "alpha",
+                },
+                [72]: "test",
+            };
+            const output = [
+                ["72", "test"],
+                ["a", 42],
+                ["b", [
+                    ["a", "test"],
+                    ["b", "alpha"],
+                    ["d", []],
+                ]],
+            ];
+
+            expect(deepSortedObjectEntries(input)).toMatchObject(output);
+        });
+    });
+
+    describe("recursivelyAssign", () => {
+        it("doesn't override with null/undefined", () => {
+            const result = utils.recursivelyAssign(
+                {
+                    string: "Hello world",
+                    object: {},
+                    float: 0.1,
+                }, {
+                    string: null,
+                    object: undefined,
+                },
+                true,
+            );
+
+            expect(result).toStrictEqual({
+                string: "Hello world",
+                object: {},
+                float: 0.1,
+            });
+        });
+
+        it("assigns recursively", () => {
+            const result = utils.recursivelyAssign(
+                {
+                    number: 42,
+                    object: {
+                        message: "Hello world",
+                        day: "Monday",
+                        langs: {
+                            compiled: ["c++"],
+                        },
+                    },
+                    thing: "string",
+                }, {
+                    number: 2,
+                    object: {
+                        message: "How are you",
+                        day: "Friday",
+                        langs: {
+                            compiled: ["c++", "c"],
+                        },
+                    },
+                    thing: {
+                        aSubThing: "something",
+                    },
+                },
+            );
+
+            expect(result).toStrictEqual({
+                number: 2,
+                object: {
+                    message: "How are you",
+                    day: "Friday",
+                    langs: {
+                        compiled: ["c++", "c"],
+                    },
+                },
+                thing: {
+                    aSubThing: "something",
+                },
+            });
+        });
+    });
+});

spec/unit/webrtc/call.spec.ts

@@ -0,0 +1,398 @@
+/*
+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 { TestClient } from '../../TestClient';
+import { MatrixCall, CallErrorCode, CallEvent } from '../../../src/webrtc/call';
+import { SDPStreamMetadataKey, SDPStreamMetadataPurpose } from '../../../src/webrtc/callEventTypes';
+
+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"
+);
+
+class MockRTCPeerConnection {
+    localDescription: RTCSessionDescription;
+
+    constructor() {
+        this.localDescription = {
+            sdp: DUMMY_SDP,
+            type: 'offer',
+            toJSON: function() {},
+        };
+    }
+
+    addEventListener() {}
+    createOffer() {
+        return Promise.resolve({});
+    }
+    setRemoteDescription() {
+        return Promise.resolve();
+    }
+    setLocalDescription() {
+        return Promise.resolve();
+    }
+    close() {}
+    getStats() { return []; }
+}
+
+class MockMediaStream {
+    constructor(
+        public id,
+    ) {}
+
+    getTracks() { return []; }
+    getAudioTracks() { return [{ enabled: true }]; }
+    getVideoTracks() { return [{ enabled: true }]; }
+    addEventListener() {}
+}
+
+class MockMediaDeviceInfo {
+    constructor(
+        public kind: "audio" | "video",
+    ) {}
+}
+
+class MockMediaHandler {
+    getUserMediaStream() { return new MockMediaStream("mock_stream_from_media_handler"); }
+    stopUserMediaStream() {}
+}
+
+describe('Call', function() {
+    let client;
+    let call;
+    let prevNavigator;
+    let prevDocument;
+    let prevWindow;
+
+    beforeEach(function() {
+        prevNavigator = global.navigator;
+        prevDocument = global.document;
+        prevWindow = global.window;
+
+        global.navigator = {
+            mediaDevices: {
+                // @ts-ignore Mock
+                getUserMedia: () => new MockMediaStream("local_stream"),
+                // @ts-ignore Mock
+                enumerateDevices: async () => [new MockMediaDeviceInfo("audio"), new MockMediaDeviceInfo("video")],
+            },
+        };
+
+        global.window = {
+            // @ts-ignore Mock
+            RTCPeerConnection: MockRTCPeerConnection,
+            // @ts-ignore Mock
+            RTCSessionDescription: {},
+            // @ts-ignore Mock
+            RTCIceCandidate: {},
+            getUserMedia: () => new MockMediaStream("local_stream"),
+        };
+        // @ts-ignore Mock
+        global.document = {};
+
+        client = new TestClient("@alice:foo", "somedevice", "token", undefined, {});
+        // We just stub out sendEvent: we're not interested in testing the client's
+        // event sending code here
+        client.client.sendEvent = () => {};
+        client.client.mediaHandler = new MockMediaHandler;
+        client.client.getMediaHandler = () => client.client.mediaHandler;
+        client.httpBackend.when("GET", "/voip/turnServer").respond(200, {});
+        call = new MatrixCall({
+            client: client.client,
+            roomId: '!foo:bar',
+        });
+        // call checks one of these is wired up
+        call.on('error', () => {});
+    });
+
+    afterEach(function() {
+        client.stop();
+        global.navigator = prevNavigator;
+        global.window = prevWindow;
+        global.document = prevDocument;
+    });
+
+    it('should ignore candidate events from non-matching party ID', async function() {
+        const callPromise = call.placeVoiceCall();
+        await client.httpBackend.flush();
+        await callPromise;
+        await call.onAnswerReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'the_correct_party_id',
+                    answer: {
+                        sdp: DUMMY_SDP,
+                    },
+                };
+            },
+        });
+
+        call.peerConn.addIceCandidate = jest.fn();
+        call.onRemoteIceCandidatesReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'the_correct_party_id',
+                    candidates: [
+                        {
+                            candidate: '',
+                            sdpMid: '',
+                        },
+                    ],
+                };
+            },
+        });
+        expect(call.peerConn.addIceCandidate.mock.calls.length).toBe(1);
+
+        call.onRemoteIceCandidatesReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'some_other_party_id',
+                    candidates: [
+                        {
+                            candidate: '',
+                            sdpMid: '',
+                        },
+                    ],
+                };
+            },
+        });
+        expect(call.peerConn.addIceCandidate.mock.calls.length).toBe(1);
+
+        // Hangup to stop timers
+        call.hangup(CallErrorCode.UserHangup, true);
+    });
+
+    it('should add candidates received before answer if party ID is correct', async function() {
+        const callPromise = call.placeVoiceCall();
+        await client.httpBackend.flush();
+        await callPromise;
+        call.peerConn.addIceCandidate = jest.fn();
+
+        call.onRemoteIceCandidatesReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'the_correct_party_id',
+                    candidates: [
+                        {
+                            candidate: 'the_correct_candidate',
+                            sdpMid: '',
+                        },
+                    ],
+                };
+            },
+        });
+
+        call.onRemoteIceCandidatesReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'some_other_party_id',
+                    candidates: [
+                        {
+                            candidate: 'the_wrong_candidate',
+                            sdpMid: '',
+                        },
+                    ],
+                };
+            },
+        });
+
+        expect(call.peerConn.addIceCandidate.mock.calls.length).toBe(0);
+
+        await call.onAnswerReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'the_correct_party_id',
+                    answer: {
+                        sdp: DUMMY_SDP,
+                    },
+                };
+            },
+        });
+
+        expect(call.peerConn.addIceCandidate.mock.calls.length).toBe(1);
+        expect(call.peerConn.addIceCandidate).toHaveBeenCalledWith({
+            candidate: 'the_correct_candidate',
+            sdpMid: '',
+        });
+    });
+
+    it('should map asserted identity messages to remoteAssertedIdentity', async function() {
+        const callPromise = call.placeVoiceCall();
+        await client.httpBackend.flush();
+        await callPromise;
+        await call.onAnswerReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'party_id',
+                    answer: {
+                        sdp: DUMMY_SDP,
+                    },
+                };
+            },
+        });
+
+        const identChangedCallback = jest.fn();
+        call.on(CallEvent.AssertedIdentityChanged, identChangedCallback);
+
+        await call.onAssertedIdentityReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'party_id',
+                    asserted_identity: {
+                        id: "@steve:example.com",
+                        display_name: "Steve Gibbons",
+                    },
+                };
+            },
+        });
+
+        expect(identChangedCallback).toHaveBeenCalled();
+
+        const ident = call.getRemoteAssertedIdentity();
+        expect(ident.id).toEqual("@steve:example.com");
+        expect(ident.displayName).toEqual("Steve Gibbons");
+
+        // Hangup to stop timers
+        call.hangup(CallErrorCode.UserHangup, true);
+    });
+
+    it("should map SDPStreamMetadata to feeds", async () => {
+        const callPromise = call.placeVoiceCall();
+        await client.httpBackend.flush();
+        await callPromise;
+
+        call.getOpponentMember = () => {
+            return { userId: "@bob:bar.uk" };
+        };
+
+        await call.onAnswerReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'party_id',
+                    answer: {
+                        sdp: DUMMY_SDP,
+                    },
+                    [SDPStreamMetadataKey]: {
+                        "remote_stream": {
+                            purpose: SDPStreamMetadataPurpose.Usermedia,
+                            audio_muted: true,
+                            video_muted: false,
+                        },
+                    },
+                };
+            },
+        });
+
+        call.pushRemoteFeed(new MockMediaStream("remote_stream"));
+        const feed = call.getFeeds().find((feed) => feed.stream.id === "remote_stream");
+        expect(feed?.purpose).toBe(SDPStreamMetadataPurpose.Usermedia);
+        expect(feed?.isAudioMuted()).toBeTruthy();
+        expect(feed?.isVideoMuted()).not.toBeTruthy();
+    });
+
+    it("should fallback to replaceTrack() if the other side doesn't support SPDStreamMetadata", async () => {
+        const callPromise = call.placeVoiceCall();
+        await client.httpBackend.flush();
+        await callPromise;
+
+        call.getOpponentMember = () => {
+            return { userId: "@bob:bar.uk" };
+        };
+
+        await call.onAnswerReceived({
+            getContent: () => {
+                return {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: 'party_id',
+                    answer: {
+                        sdp: DUMMY_SDP,
+                    },
+                };
+            },
+        });
+
+        call.setScreensharingEnabledWithoutMetadataSupport = jest.fn();
+
+        call.setScreensharingEnabled(true);
+        expect(call.setScreensharingEnabledWithoutMetadataSupport).toHaveBeenCalled();
+    });
+
+    it("should fallback to answering with no video", async () => {
+        await client.httpBackend.flush();
+
+        call.shouldAnswerWithMediaType = (wantedValue: boolean) => wantedValue;
+        client.client.mediaHandler.getUserMediaStream = jest.fn().mockRejectedValue("reject");
+
+        await call.answer(true, true);
+
+        expect(client.client.mediaHandler.getUserMediaStream).toHaveBeenNthCalledWith(1, true, true);
+        expect(client.client.mediaHandler.getUserMediaStream).toHaveBeenNthCalledWith(2, true, false);
+    });
+});

src/@types/IIdentityServerProvider.ts

@@ -0,0 +1,24 @@
+/*
+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.
+*/
+
+export interface IIdentityServerProvider {
+    /**
+     * Gets an access token for use against the identity server,
+     * for the associated client.
+     * @returns {Promise<string>} Resolves to the access token.
+     */
+    getAccessToken(): Promise<string>;
+}

src/@types/PushRules.ts

@@ -0,0 +1,165 @@
+/*
+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.
+*/
+
+// allow camelcase as these are things that go onto the wire
+/* eslint-disable camelcase */
+
+export enum PushRuleActionName {
+    DontNotify = "dont_notify",
+    Notify = "notify",
+    Coalesce = "coalesce",
+}
+
+export enum TweakName {
+    Highlight = "highlight",
+    Sound = "sound",
+}
+
+export type Tweak<N extends TweakName, V> = {
+    set_tweak: N;
+    value: V;
+};
+
+export type TweakHighlight = Tweak<TweakName.Highlight, boolean>;
+export type TweakSound = Tweak<TweakName.Sound, string>;
+
+export type Tweaks = TweakHighlight | TweakSound;
+
+export enum ConditionOperator {
+    ExactEquals = "==",
+    LessThan = "<",
+    GreaterThan = ">",
+    GreaterThanOrEqual = ">=",
+    LessThanOrEqual = "<=",
+}
+
+export type PushRuleAction = Tweaks | PushRuleActionName;
+
+export type MemberCountCondition
+    <N extends number, Op extends ConditionOperator = ConditionOperator.ExactEquals>
+    = `${Op}${N}` | (Op extends ConditionOperator.ExactEquals ? `${N}` : never);
+
+export type AnyMemberCountCondition = MemberCountCondition<number, ConditionOperator>;
+
+export const DMMemberCountCondition: MemberCountCondition<2> = "2";
+
+export function isDmMemberCountCondition(condition: AnyMemberCountCondition): boolean {
+    return condition === "==2" || condition === "2";
+}
+
+export enum ConditionKind {
+    EventMatch = "event_match",
+    ContainsDisplayName = "contains_display_name",
+    RoomMemberCount = "room_member_count",
+    SenderNotificationPermission = "sender_notification_permission",
+}
+
+export interface IPushRuleCondition<N extends ConditionKind | string> {
+    [k: string]: any; // for custom conditions, there can be other fields here
+    kind: N;
+}
+
+export interface IEventMatchCondition extends IPushRuleCondition<ConditionKind.EventMatch> {
+    key: string;
+    pattern: string;
+}
+
+export interface IContainsDisplayNameCondition extends IPushRuleCondition<ConditionKind.ContainsDisplayName> {
+    // no additional fields
+}
+
+export interface IRoomMemberCountCondition extends IPushRuleCondition<ConditionKind.RoomMemberCount> {
+    is: AnyMemberCountCondition;
+}
+
+export interface ISenderNotificationPermissionCondition
+    extends IPushRuleCondition<ConditionKind.SenderNotificationPermission> {
+    key: string;
+}
+
+// XXX: custom conditions are possible but always fail, and break the typescript discriminated union so ignore them here
+// IPushRuleCondition<Exclude<string, ConditionKind>> unfortunately does not resolve this at the time of writing.
+export type PushRuleCondition = IEventMatchCondition
+    | IContainsDisplayNameCondition
+    | IRoomMemberCountCondition
+    | ISenderNotificationPermissionCondition;
+
+export enum PushRuleKind {
+    Override = "override",
+    ContentSpecific = "content",
+    RoomSpecific = "room",
+    SenderSpecific = "sender",
+    Underride = "underride",
+}
+
+export enum RuleId {
+    Master = ".m.rule.master",
+    ContainsDisplayName = ".m.rule.contains_display_name",
+    ContainsUserName = ".m.rule.contains_user_name",
+    AtRoomNotification = ".m.rule.roomnotif",
+    DM = ".m.rule.room_one_to_one",
+    EncryptedDM = ".m.rule.encrypted_room_one_to_one",
+    Message = ".m.rule.message",
+    EncryptedMessage = ".m.rule.encrypted",
+    InviteToSelf = ".m.rule.invite_for_me",
+    MemberEvent = ".m.rule.member_event",
+    IncomingCall = ".m.rule.call",
+    SuppressNotices = ".m.rule.suppress_notices",
+    Tombstone = ".m.rule.tombstone",
+}
+
+export type PushRuleSet = {
+    [k in PushRuleKind]?: IPushRule[];
+};
+
+export interface IPushRule {
+    actions: PushRuleAction[];
+    conditions?: PushRuleCondition[];
+    default: boolean;
+    enabled: boolean;
+    pattern?: string;
+    rule_id: RuleId | string;
+}
+
+export interface IAnnotatedPushRule extends IPushRule {
+    kind: PushRuleKind;
+}
+
+export interface IPushRules {
+    global: PushRuleSet;
+    device?: PushRuleSet;
+}
+
+export interface IPusher {
+    app_display_name: string;
+    app_id: string;
+    data: {
+        format?: string; // TODO: Types
+        url?: string; // TODO: Required if kind==http
+        brand?: string; // TODO: For email notifications only?
+    };
+    device_display_name: string;
+    kind: string; // TODO: Types
+    lang: string;
+    profile_tag?: string;
+    pushkey: string;
+}
+
+export interface IPusherRequest extends IPusher {
+    append?: boolean;
+}
+
+/* eslint-enable camelcase */

src/@types/another-json.ts

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 The Matrix.org Foundation C.I.C.
+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.
@@ -14,7 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-export const SERVICE_TYPES = Object.freeze({
-    IS: 'SERVICE_TYPE_IS', // An Identity Service
-    IM: 'SERVICE_TYPE_IM', // An Integration Manager
-});
+declare module "another-json" {
+    export function stringify(o: object): string;
+}

src/@types/event.ts

@@ -0,0 +1,192 @@
+/*
+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 { UnstableValue } from "../NamespacedValue";
+
+export enum EventType {
+    // Room state events
+    RoomCanonicalAlias = "m.room.canonical_alias",
+    RoomCreate = "m.room.create",
+    RoomJoinRules = "m.room.join_rules",
+    RoomMember = "m.room.member",
+    RoomThirdPartyInvite = "m.room.third_party_invite",
+    RoomPowerLevels = "m.room.power_levels",
+    RoomName = "m.room.name",
+    RoomTopic = "m.room.topic",
+    RoomAvatar = "m.room.avatar",
+    RoomPinnedEvents = "m.room.pinned_events",
+    RoomEncryption = "m.room.encryption",
+    RoomHistoryVisibility = "m.room.history_visibility",
+    RoomGuestAccess = "m.room.guest_access",
+    RoomServerAcl = "m.room.server_acl",
+    RoomTombstone = "m.room.tombstone",
+    /**
+     * @deprecated Should not be used.
+     */
+    RoomAliases = "m.room.aliases", // deprecated https://matrix.org/docs/spec/client_server/r0.6.1#historical-events
+
+    SpaceChild = "m.space.child",
+    SpaceParent = "m.space.parent",
+
+    // Room timeline events
+    RoomRedaction = "m.room.redaction",
+    RoomMessage = "m.room.message",
+    RoomMessageEncrypted = "m.room.encrypted",
+    Sticker = "m.sticker",
+    CallInvite = "m.call.invite",
+    CallCandidates = "m.call.candidates",
+    CallAnswer = "m.call.answer",
+    CallHangup = "m.call.hangup",
+    CallReject = "m.call.reject",
+    CallSelectAnswer = "m.call.select_answer",
+    CallNegotiate = "m.call.negotiate",
+    CallSDPStreamMetadataChanged = "m.call.sdp_stream_metadata_changed",
+    CallSDPStreamMetadataChangedPrefix = "org.matrix.call.sdp_stream_metadata_changed",
+    CallReplaces = "m.call.replaces",
+    CallAssertedIdentity = "m.call.asserted_identity",
+    CallAssertedIdentityPrefix = "org.matrix.call.asserted_identity",
+    KeyVerificationRequest = "m.key.verification.request",
+    KeyVerificationStart = "m.key.verification.start",
+    KeyVerificationCancel = "m.key.verification.cancel",
+    KeyVerificationMac = "m.key.verification.mac",
+    KeyVerificationDone = "m.key.verification.done",
+    // use of this is discouraged https://matrix.org/docs/spec/client_server/r0.6.1#m-room-message-feedback
+    RoomMessageFeedback = "m.room.message.feedback",
+    Reaction = "m.reaction",
+
+    // Room ephemeral events
+    Typing = "m.typing",
+    Receipt = "m.receipt",
+    Presence = "m.presence",
+
+    // Room account_data events
+    FullyRead = "m.fully_read",
+    Tag = "m.tag",
+    SpaceOrder = "org.matrix.msc3230.space_order", // MSC3230
+
+    // User account_data events
+    PushRules = "m.push_rules",
+    Direct = "m.direct",
+    IgnoredUserList = "m.ignored_user_list",
+
+    // to_device events
+    RoomKey = "m.room_key",
+    RoomKeyRequest = "m.room_key_request",
+    ForwardedRoomKey = "m.forwarded_room_key",
+    Dummy = "m.dummy",
+}
+
+export enum RelationType {
+    Annotation = "m.annotation",
+    Replace = "m.replace",
+    /**
+     * Note, "io.element.thread" is hardcoded
+     * Should be replaced with "m.thread" once MSC3440 lands
+     * Can not use `UnstableValue` as TypeScript does not
+     * allow computed values in enums
+     * https://github.com/microsoft/TypeScript/issues/27976
+     */
+    Thread = "io.element.thread",
+}
+
+export enum MsgType {
+    Text = "m.text",
+    Emote = "m.emote",
+    Notice = "m.notice",
+    Image = "m.image",
+    File = "m.file",
+    Audio = "m.audio",
+    Location = "m.location",
+    Video = "m.video",
+}
+
+export const RoomCreateTypeField = "type";
+
+export enum RoomType {
+    Space = "m.space",
+}
+
+/**
+ * Identifier for an [MSC3088](https://github.com/matrix-org/matrix-doc/pull/3088)
+ * room purpose. Note that this reference is UNSTABLE and subject to breaking changes,
+ * including its eventual removal.
+ */
+export const UNSTABLE_MSC3088_PURPOSE = new UnstableValue("m.room.purpose", "org.matrix.msc3088.purpose");
+
+/**
+ * Enabled flag for an [MSC3088](https://github.com/matrix-org/matrix-doc/pull/3088)
+ * room purpose. Note that this reference is UNSTABLE and subject to breaking changes,
+ * including its eventual removal.
+ */
+export const UNSTABLE_MSC3088_ENABLED = new UnstableValue("m.enabled", "org.matrix.msc3088.enabled");
+
+/**
+ * Subtype for an [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) space-room.
+ * Note that this reference is UNSTABLE and subject to breaking changes, including its
+ * eventual removal.
+ */
+export const UNSTABLE_MSC3089_TREE_SUBTYPE = new UnstableValue("m.data_tree", "org.matrix.msc3089.data_tree");
+
+/**
+ * Leaf type for an event in a [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) space-room.
+ * Note that this reference is UNSTABLE and subject to breaking changes, including its
+ * eventual removal.
+ */
+export const UNSTABLE_MSC3089_LEAF = new UnstableValue("m.leaf", "org.matrix.msc3089.leaf");
+
+/**
+ * Branch (Leaf Reference) type for the index approach in a
+ * [MSC3089](https://github.com/matrix-org/matrix-doc/pull/3089) space-room. Note that this reference is
+ * UNSTABLE and subject to breaking changes, including its eventual removal.
+ */
+export const UNSTABLE_MSC3089_BRANCH = new UnstableValue("m.branch", "org.matrix.msc3089.branch");
+
+/**
+ * Functional members type for declaring a purpose of room members (e.g. helpful bots).
+ * Note that this reference is UNSTABLE and subject to breaking changes, including its
+ * eventual removal.
+ *
+ * Schema (TypeScript):
+ * {
+ *   service_members?: string[]
+ * }
+ *
+ * Example:
+ * {
+ *   "service_members": [
+ *     "@helperbot:localhost",
+ *     "@reminderbot:alice.tdl"
+ *   ]
+ * }
+ */
+export const UNSTABLE_ELEMENT_FUNCTIONAL_USERS = new UnstableValue(
+    "io.element.functional_members",
+    "io.element.functional_members");
+
+export interface IEncryptedFile {
+    url: string;
+    mimetype?: string;
+    key: {
+        alg: string;
+        key_ops: string[]; // eslint-disable-line camelcase
+        kty: string;
+        k: string;
+        ext: boolean;
+    };
+    iv: string;
+    hashes: {[alg: string]: string};
+    v: string;
+}

src/@types/global.d.ts

@@ -0,0 +1,98 @@
+/*
+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.
+*/
+
+// this is needed to tell TS about global.Olm
+import "@matrix-org/olm";
+
+export {};
+
+declare global {
+    // use `number` as the return type in all cases for global.set{Interval,Timeout},
+    // so we don't accidentally use the methods on NodeJS.Timeout - they only exist in a subset of environments.
+    // The overload for clear{Interval,Timeout} is resolved as expected.
+    function setInterval(handler: TimerHandler, timeout: number, ...arguments: any[]): number;
+    function setTimeout(handler: TimerHandler, timeout: number, ...arguments: any[]): number;
+
+    namespace NodeJS {
+        interface Global {
+            localStorage: Storage;
+        }
+    }
+
+    interface Window {
+        webkitAudioContext: typeof AudioContext;
+    }
+
+    interface Crypto {
+        webkitSubtle?: Window["crypto"]["subtle"];
+    }
+
+    interface MediaDevices {
+        // This is experimental and types don't know about it yet
+        // https://github.com/microsoft/TypeScript/issues/33232
+        getDisplayMedia(constraints: MediaStreamConstraints | DesktopCapturerConstraints): Promise<MediaStream>;
+        getUserMedia(constraints: MediaStreamConstraints | DesktopCapturerConstraints): Promise<MediaStream>;
+    }
+
+    interface DesktopCapturerConstraints {
+        audio: boolean | {
+            mandatory: {
+                chromeMediaSource: string;
+                chromeMediaSourceId: string;
+            };
+        };
+        video: boolean | {
+            mandatory: {
+                chromeMediaSource: string;
+                chromeMediaSourceId: string;
+            };
+        };
+    }
+
+    interface HTMLAudioElement {
+        // sinkId & setSinkId are experimental and typescript doesn't know about them
+        sinkId: string;
+        setSinkId(outputId: string);
+    }
+
+    interface DummyInterfaceWeShouldntBeUsingThis {}
+
+    interface Navigator {
+        // We check for the webkit-prefixed getUserMedia to detect if we're
+        // on webkit: we should check if we still need to do this
+        webkitGetUserMedia: DummyInterfaceWeShouldntBeUsingThis;
+    }
+
+    export interface ISettledFulfilled<T> {
+        status: "fulfilled";
+        value: T;
+    }
+    export interface ISettledRejected {
+        status: "rejected";
+        reason: any;
+    }
+
+    interface PromiseConstructor {
+        allSettled<T>(promises: Promise<T>[]): Promise<Array<ISettledFulfilled<T> | ISettledRejected>>;
+    }
+
+    interface RTCRtpTransceiver {
+        // This has been removed from TS
+        // (https://github.com/microsoft/TypeScript-DOM-lib-generator/issues/1029),
+        // but we still need this for MatrixCall::getRidOfRTXCodecs()
+        setCodecPreferences(codecs: RTCRtpCodecCapability[]): void;
+    }
+}

src/@types/partials.ts

@@ -0,0 +1,84 @@
+/*
+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.
+*/
+
+export interface IImageInfo {
+    size?: number;
+    mimetype?: string;
+    thumbnail_info?: { // eslint-disable-line camelcase
+        w?: number;
+        h?: number;
+        size?: number;
+        mimetype?: string;
+    };
+    w?: number;
+    h?: number;
+}
+
+export enum Visibility {
+    Public = "public",
+    Private = "private",
+}
+
+export enum Preset {
+    PrivateChat = "private_chat",
+    TrustedPrivateChat = "trusted_private_chat",
+    PublicChat = "public_chat",
+}
+
+export type ResizeMethod = "crop" | "scale";
+
+// TODO move to http-api after TSification
+export interface IAbortablePromise<T> extends Promise<T> {
+    abort(): void;
+}
+
+export type IdServerUnbindResult = "no-support" | "success";
+
+// Knock and private are reserved keywords which are not yet implemented.
+export enum JoinRule {
+    Public = "public",
+    Invite = "invite",
+    /**
+     * @deprecated Reserved keyword. Should not be used. Not yet implemented.
+     */
+    Private = "private",
+    Knock = "knock",
+    Restricted = "restricted",
+}
+
+export enum RestrictedAllowType {
+    RoomMembership = "m.room_membership",
+}
+
+export interface IJoinRuleEventContent {
+    join_rule: JoinRule; // eslint-disable-line camelcase
+    allow?: {
+        type: RestrictedAllowType;
+        room_id: string; // eslint-disable-line camelcase
+    }[];
+}
+
+export enum GuestAccess {
+    CanJoin = "can_join",
+    Forbidden = "forbidden",
+}
+
+export enum HistoryVisibility {
+    Invited = "invited",
+    Joined = "joined",
+    Shared = "shared",
+    WorldReadable = "world_readable",
+}

src/@types/requests.ts

@@ -0,0 +1,142 @@
+/*
+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 { Callback } from "../client";
+import { IContent } from "../models/event";
+import { Preset, Visibility } from "./partials";
+import { SearchKey } from "./search";
+import { IRoomEventFilter } from "../filter";
+
+// allow camelcase as these are things that go onto the wire
+/* eslint-disable camelcase */
+
+export interface IJoinRoomOpts {
+    /**
+     * True to do a room initial sync on the resulting
+     * room. If false, the <strong>returned Room object will have no current state.
+     * </strong> Default: true.
+     */
+    syncRoom?: boolean;
+
+    /**
+     * If the caller has a keypair 3pid invite, the signing URL is passed in this parameter.
+     */
+    inviteSignUrl?: string;
+
+    /**
+     * The server names to try and join through in addition to those that are automatically chosen.
+     */
+    viaServers?: string[];
+}
+
+export interface IRedactOpts {
+    reason?: string;
+}
+
+export interface ISendEventResponse {
+    event_id: string;
+}
+
+export interface IPresenceOpts {
+    presence: "online" | "offline" | "unavailable";
+    status_msg?: string;
+}
+
+export interface IPaginateOpts {
+    backwards?: boolean;
+    limit?: number;
+}
+
+export interface IGuestAccessOpts {
+    allowJoin: boolean;
+    allowRead: boolean;
+}
+
+export interface ISearchOpts {
+    keys?: SearchKey[];
+    query: string;
+}
+
+export interface IEventSearchOpts {
+    filter?: IRoomEventFilter;
+    term: string;
+}
+
+export interface IInvite3PID {
+    id_server: string;
+    id_access_token?: string; // this gets injected by the js-sdk
+    medium: string;
+    address: string;
+}
+
+export interface ICreateRoomStateEvent {
+    type: string;
+    state_key?: string; // defaults to an empty string
+    content: IContent;
+}
+
+export interface ICreateRoomOpts {
+    room_alias_name?: string;
+    visibility?: Visibility;
+    name?: string;
+    topic?: string;
+    preset?: Preset;
+    power_level_content_override?: object;
+    creation_content?: object;
+    initial_state?: ICreateRoomStateEvent[];
+    invite?: string[];
+    invite_3pid?: IInvite3PID[];
+    is_direct?: boolean;
+    room_version?: string;
+}
+
+export interface IRoomDirectoryOptions {
+    server?: string;
+    limit?: number;
+    since?: string;
+    filter?: {
+        generic_search_term: string;
+    };
+    include_all_networks?: boolean;
+    third_party_instance_id?: string;
+}
+
+export interface IUploadOpts {
+    name?: string;
+    includeFilename?: boolean;
+    type?: string;
+    rawResponse?: boolean;
+    onlyContentUri?: boolean;
+    callback?: Callback;
+    progressHandler?: (state: {loaded: number, total: number}) => void;
+}
+
+export interface IAddThreePidOnlyBody {
+    auth?: {
+        type: string;
+        session?: string;
+    };
+    client_secret: string;
+    sid: string;
+}
+
+export interface IBindThreePidBody {
+    client_secret: string;
+    id_server: string;
+    id_access_token: string;
+    sid: string;
+}
+/* eslint-enable camelcase */

src/@types/search.ts

@@ -0,0 +1,118 @@
+/*
+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.
+*/
+
+// Types relating to the /search API
+
+import { IRoomEvent, IStateEvent } from "../sync-accumulator";
+import { IRoomEventFilter } from "../filter";
+import { SearchResult } from "../models/search-result";
+
+/* eslint-disable camelcase */
+export interface IEventWithRoomId extends IRoomEvent {
+    room_id: string;
+}
+
+export interface IStateEventWithRoomId extends IStateEvent {
+    room_id: string;
+}
+
+export interface IMatrixProfile {
+    avatar_url?: string;
+    displayname?: string;
+}
+
+export interface IResultContext {
+    events_before: IEventWithRoomId[];
+    events_after: IEventWithRoomId[];
+    profile_info: Record<string, IMatrixProfile>;
+    start?: string;
+    end?: string;
+}
+
+export interface ISearchResult {
+    rank: number;
+    result: IEventWithRoomId;
+    context: IResultContext;
+}
+
+enum GroupKey {
+    RoomId = "room_id",
+    Sender = "sender",
+}
+
+export interface IResultRoomEvents {
+    count: number;
+    highlights: string[];
+    results: ISearchResult[];
+    state?: { [roomId: string]: IStateEventWithRoomId[] };
+    groups?: {
+        [groupKey in GroupKey]: {
+            [value: string]: {
+                next_batch?: string;
+                order: number;
+                results: string[];
+            };
+        };
+    };
+    next_batch?: string;
+}
+
+interface IResultCategories {
+    room_events: IResultRoomEvents;
+}
+
+export type SearchKey = "content.body" | "content.name" | "content.topic";
+
+export enum SearchOrderBy {
+    Recent = "recent",
+    Rank = "rank",
+}
+
+export interface ISearchRequestBody {
+    search_categories: {
+        room_events: {
+            search_term: string;
+            keys?: SearchKey[];
+            filter?: IRoomEventFilter;
+            order_by?: SearchOrderBy;
+            event_context?: {
+                before_limit?: number;
+                after_limit?: number;
+                include_profile?: boolean;
+            };
+            include_state?: boolean;
+            groupings?: {
+                group_by: {
+                    key: GroupKey;
+                }[];
+            };
+        };
+    };
+}
+
+export interface ISearchResponse {
+    search_categories: IResultCategories;
+}
+
+export interface ISearchResults {
+    _query?: ISearchRequestBody;
+    results: SearchResult[];
+    highlights: string[];
+    count?: number;
+    next_batch?: string;
+    pendingRequest?: Promise<ISearchResults>;
+}
+/* eslint-enable camelcase */

src/@types/signed.ts

@@ -0,0 +1,25 @@
+/*
+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.
+*/
+
+export interface ISignatures {
+    [entity: string]: {
+        [keyId: string]: string;
+    };
+}
+
+export interface ISigned {
+    signatures?: ISignatures;
+}

src/@types/spaces.ts

@@ -0,0 +1,60 @@
+/*
+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 { IPublicRoomsChunkRoom } from "../client";
+import { RoomType } from "./event";
+import { IStrippedState } from "../sync-accumulator";
+
+// Types relating to Rooms of type `m.space` and related APIs
+
+/* eslint-disable camelcase */
+/** @deprecated Use hierarchy instead where possible. */
+export interface ISpaceSummaryRoom extends IPublicRoomsChunkRoom {
+    num_refs: number;
+    room_type: string;
+}
+
+/** @deprecated Use hierarchy instead where possible. */
+export interface ISpaceSummaryEvent {
+    room_id: string;
+    event_id: string;
+    origin_server_ts: number;
+    type: string;
+    state_key: string;
+    sender: string;
+    content: {
+        order?: string;
+        suggested?: boolean;
+        auto_join?: boolean;
+        via?: string[];
+    };
+}
+
+export interface IHierarchyRelation extends IStrippedState {
+    room_id: string;
+    origin_server_ts: number;
+    content: {
+        order?: string;
+        suggested?: boolean;
+        via?: string[];
+    };
+}
+
+export interface IHierarchyRoom extends IPublicRoomsChunkRoom {
+    room_type?: RoomType | string;
+    children_state: IHierarchyRelation[];
+}
+/* eslint-enable camelcase */

src/@types/synapse.ts

@@ -0,0 +1,40 @@
+/*
+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 { IdServerUnbindResult } from "./partials";
+
+// Types relating to Synapse Admin APIs
+
+/* eslint-disable camelcase */
+export interface ISynapseAdminWhoisResponse {
+    user_id: string;
+    devices: {
+        [deviceId: string]: {
+            sessions: {
+                connections: {
+                    ip: string;
+                    last_seen: number; // millis since epoch
+                    user_agent: string;
+                }[];
+            }[];
+        };
+    };
+}
+
+export interface ISynapseAdminDeactivateResponse {
+    id_server_unbind_result: IdServerUnbindResult;
+}
+/* eslint-enable camelcase */

src/@types/threepids.ts

@@ -0,0 +1,29 @@
+/*
+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.
+*/
+
+export enum ThreepidMedium {
+    Email = "email",
+    Phone = "msisdn",
+}
+
+// TODO: Are these types universal, or specific to just /account/3pid?
+export interface IThreepid {
+    medium: ThreepidMedium;
+    address: string;
+    validated_at: number; // eslint-disable-line camelcase
+    added_at: number; // eslint-disable-line camelcase
+    bound?: boolean;
+}

src/NamespacedValue.ts

@@ -0,0 +1,93 @@
+/*
+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.
+*/
+
+/**
+ * Represents a simple Matrix namespaced value. This will assume that if a stable prefix
+ * is provided that the stable prefix should be used when representing the identifier.
+ */
+export class NamespacedValue<S extends string, U extends string> {
+    // Stable is optional, but one of the two parameters is required, hence the weird-looking types.
+    // Goal is to to have developers explicitly say there is no stable value (if applicable).
+    public constructor(public readonly stable: S | null | undefined, public readonly unstable?: U) {
+        if (!this.unstable && !this.stable) {
+            throw new Error("One of stable or unstable values must be supplied");
+        }
+    }
+
+    public get name(): U | S {
+        if (this.stable) {
+            return this.stable;
+        }
+        return this.unstable;
+    }
+
+    public get altName(): U | S | null {
+        if (!this.stable) {
+            return null;
+        }
+        return this.unstable;
+    }
+
+    public matches(val: string): boolean {
+        return this.name === val || this.altName === val;
+    }
+
+    // this desperately wants https://github.com/microsoft/TypeScript/pull/26349 at the top level of the class
+    // so we can instantiate `NamespacedValue<string, _, _>` as a default type for that namespace.
+    public findIn<T>(obj: any): T {
+        let val: T;
+        if (this.name) {
+            val = obj?.[this.name];
+        }
+        if (!val && this.altName) {
+            val = obj?.[this.altName];
+        }
+        return val;
+    }
+
+    public includedIn(arr: any[]): boolean {
+        let included = false;
+        if (this.name) {
+            included = arr.includes(this.name);
+        }
+        if (!included && this.altName) {
+            included = arr.includes(this.altName);
+        }
+        return included;
+    }
+}
+
+/**
+ * Represents a namespaced value which prioritizes the unstable value over the stable
+ * value.
+ */
+export class UnstableValue<S extends string, U extends string> extends NamespacedValue<S, U> {
+    // Note: Constructor difference is that `unstable` is *required*.
+    public constructor(stable: S, unstable: U) {
+        super(stable, unstable);
+        if (!this.unstable) {
+            throw new Error("Unstable value must be supplied");
+        }
+    }
+
+    public get name(): U {
+        return this.unstable;
+    }
+
+    public get altName(): S {
+        return this.stable;
+    }
+}

src/ReEmitter.js

@@ -1,52 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2017 Vector Creations Ltd
-Copyright 2017 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.
-*/
-
-/**
- * @module
- */
-
-export class ReEmitter {
-    constructor(target) {
-        this.target = target;
-
-        // We keep one bound event handler for each event name so we know
-        // what event is arriving
-        this.boundHandlers = {};
-    }
-
-    _handleEvent(eventName, ...args) {
-        this.target.emit(eventName, ...args);
-    }
-
-    reEmit(source, eventNames) {
-        // We include the source as the last argument for event handlers which may need it,
-        // such as read receipt listeners on the client class which won't have the context
-        // of the room.
-        const forSource = (handler, ...args) => {
-            handler(...args, source);
-        };
-        for (const eventName of eventNames) {
-            if (this.boundHandlers[eventName] === undefined) {
-                this.boundHandlers[eventName] = this._handleEvent.bind(this, eventName);
-            }
-
-            const boundHandler = forSource.bind(this, this.boundHandlers[eventName]);
-            source.on(eventName, boundHandler);
-        }
-    }
-}

src/ReEmitter.ts

@@ -0,0 +1,50 @@
+/*
+Copyright 2015, 2016 OpenMarket Ltd
+Copyright 2017 Vector Creations Ltd
+Copyright 2017 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 { EventEmitter } from "events";
+
+export class ReEmitter {
+    private target: EventEmitter;
+
+    constructor(target: EventEmitter) {
+        this.target = target;
+    }
+
+    reEmit(source: EventEmitter, eventNames: string[]) {
+        for (const eventName of eventNames) {
+            // We include the source as the last argument for event handlers which may need it,
+            // such as read receipt listeners on the client class which won't have the context
+            // of the room.
+            const forSource = (...args) => {
+                // EventEmitter special cases 'error' to make the emit function throw if no
+                // handler is attached, which sort of makes sense for making sure that something
+                // handles an error, but for re-emitting, there could be a listener on the original
+                // source object so the test doesn't really work. We *could* try to replicate the
+                // same logic and throw if there is no listener on either the source or the target,
+                // but this behaviour is fairly undesireable for us anyway: the main place we throw
+                // 'error' events is for calls, where error events are usually emitted some time
+                // later by a different part of the code where 'emit' throwing because the app hasn't
+                // added an error handler isn't terribly helpful. (A better fix in retrospect may
+                // have been to just avoid using the event name 'error', but backwards compat...)
+                if (eventName === 'error' && this.target.listenerCount('error') === 0) return;
+                this.target.emit(eventName, ...args, source);
+            };
+            source.on(eventName, forSource);
+        }
+    }
+}

src/autodiscovery.ts

@@ -17,79 +17,19 @@ limitations under the License.
 
 /** @module auto-discovery */
 
-import {logger} from './logger';
-import {URL as NodeURL} from "url";
+import { IClientWellKnown, IWellKnownConfig } from "./client";
+import { logger } from './logger';
+import { URL as NodeURL } from "url";
 
 // Dev note: Auto discovery is part of the spec.
 // See: https://matrix.org/docs/spec/client_server/r0.4.0.html#server-discovery
 
-/**
- * Description for what an automatically discovered client configuration
- * would look like. Although this is a class, it is recommended that it
- * be treated as an interface definition rather than as a class.
- *
- * Additional properties than those defined here may be present, and
- * should follow the Java package naming convention.
- */
-class DiscoveredClientConfig { // eslint-disable-line no-unused-vars
-    // Dev note: this is basically a copy/paste of the .well-known response
-    // object as defined in the spec. It does have additional information,
-    // however. Overall, this exists to serve as a place for documentation
-    // and not functionality.
-    // See https://matrix.org/docs/spec/client_server/r0.4.0.html#get-well-known-matrix-client
-
-    constructor() {
-        /**
-         * The homeserver configuration the client should use. This will
-         * always be present on the object.
-         * @type {{state: string, base_url: string}} The configuration.
-         */
-        this["m.homeserver"] = {
-            /**
-             * The lookup result state. If this is anything other than
-             * AutoDiscovery.SUCCESS then base_url may be falsey. Additionally,
-             * if this is not AutoDiscovery.SUCCESS then the client should
-             * assume the other properties in the client config (such as
-             * the identity server configuration) are not valid.
-             */
-            state: AutoDiscovery.PROMPT,
-
-            /**
-             * If the state is AutoDiscovery.FAIL_ERROR or .FAIL_PROMPT
-             * then this will contain a human-readable (English) message
-             * for what went wrong. If the state is none of those previously
-             * mentioned, this will be falsey.
-             */
-            error: "Something went wrong",
-
-            /**
-             * The base URL clients should use to talk to the homeserver,
-             * particularly for the login process. May be falsey if the
-             * state is not AutoDiscovery.SUCCESS.
-             */
-            base_url: "https://matrix.org",
-        };
-
-        /**
-         * The identity server configuration the client should use. This
-         * will always be present on teh object.
-         * @type {{state: string, base_url: string}} The configuration.
-         */
-        this["m.identity_server"] = {
-            /**
-             * The lookup result state. If this is anything other than
-             * AutoDiscovery.SUCCESS then base_url may be falsey.
-             */
-            state: AutoDiscovery.PROMPT,
-
-            /**
-             * The base URL clients should use for interacting with the
-             * identity server. May be falsey if the state is not
-             * AutoDiscovery.SUCCESS.
-             */
-            base_url: "https://vector.im",
-        };
-    }
+export enum AutoDiscoveryAction {
+    SUCCESS = "SUCCESS",
+    IGNORE = "IGNORE",
+    PROMPT = "PROMPT",
+    FAIL_PROMPT = "FAIL_PROMPT",
+    FAIL_ERROR = "FAIL_ERROR",
 }
 
 /**
@@ -102,55 +42,36 @@ export class AutoDiscovery {
     // translate the meaning of the states in the spec, but also
     // support our own if needed.
 
-    static get ERROR_INVALID() {
-        return "Invalid homeserver discovery response";
-    }
+    public static readonly ERROR_INVALID = "Invalid homeserver discovery response";
 
-    static get ERROR_GENERIC_FAILURE() {
-        return "Failed to get autodiscovery configuration from server";
-    }
+    public static readonly ERROR_GENERIC_FAILURE = "Failed to get autodiscovery configuration from server";
 
-    static get ERROR_INVALID_HS_BASE_URL() {
-        return "Invalid base_url for m.homeserver";
-    }
+    public static readonly ERROR_INVALID_HS_BASE_URL = "Invalid base_url for m.homeserver";
 
-    static get ERROR_INVALID_HOMESERVER() {
-        return "Homeserver URL does not appear to be a valid Matrix homeserver";
-    }
+    public static readonly ERROR_INVALID_HOMESERVER = "Homeserver URL does not appear to be a valid Matrix homeserver";
 
-    static get ERROR_INVALID_IS_BASE_URL() {
-        return "Invalid base_url for m.identity_server";
-    }
+    public static readonly ERROR_INVALID_IS_BASE_URL = "Invalid base_url for m.identity_server";
 
-    static get ERROR_INVALID_IDENTITY_SERVER() {
-        return "Identity server URL does not appear to be a valid identity server";
-    }
+    // eslint-disable-next-line
+    public static readonly ERROR_INVALID_IDENTITY_SERVER = "Identity server URL does not appear to be a valid identity server";
 
-    static get ERROR_INVALID_IS() {
-        return "Invalid identity server discovery response";
-    }
+    public static readonly ERROR_INVALID_IS = "Invalid identity server discovery response";
 
-    static get ERROR_MISSING_WELLKNOWN() {
-        return "No .well-known JSON file found";
-    }
+    public static readonly ERROR_MISSING_WELLKNOWN = "No .well-known JSON file found";
 
-    static get ERROR_INVALID_JSON() {
-        return "Invalid JSON";
-    }
+    public static readonly ERROR_INVALID_JSON = "Invalid JSON";
 
-    static get ALL_ERRORS() {
-        return [
-            AutoDiscovery.ERROR_INVALID,
-            AutoDiscovery.ERROR_GENERIC_FAILURE,
-            AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
-            AutoDiscovery.ERROR_INVALID_HOMESERVER,
-            AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
-            AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
-            AutoDiscovery.ERROR_INVALID_IS,
-            AutoDiscovery.ERROR_MISSING_WELLKNOWN,
-            AutoDiscovery.ERROR_INVALID_JSON,
-        ];
-    }
+    public static readonly ALL_ERRORS = [
+        AutoDiscovery.ERROR_INVALID,
+        AutoDiscovery.ERROR_GENERIC_FAILURE,
+        AutoDiscovery.ERROR_INVALID_HS_BASE_URL,
+        AutoDiscovery.ERROR_INVALID_HOMESERVER,
+        AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
+        AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
+        AutoDiscovery.ERROR_INVALID_IS,
+        AutoDiscovery.ERROR_MISSING_WELLKNOWN,
+        AutoDiscovery.ERROR_INVALID_JSON,
+    ];
 
     /**
      * The auto discovery failed. The client is expected to communicate
@@ -158,7 +79,7 @@ export class AutoDiscovery {
      * @return {string}
      * @constructor
      */
-    static get FAIL_ERROR() { return "FAIL_ERROR"; }
+    public static readonly FAIL_ERROR = AutoDiscoveryAction.FAIL_ERROR;
 
     /**
      * The auto discovery failed, however the client may still recover
@@ -169,7 +90,7 @@ export class AutoDiscovery {
      * @return {string}
      * @constructor
      */
-    static get FAIL_PROMPT() { return "FAIL_PROMPT"; }
+    public static readonly FAIL_PROMPT = AutoDiscoveryAction.FAIL_PROMPT;
 
     /**
      * The auto discovery didn't fail but did not find anything of
@@ -178,14 +99,14 @@ export class AutoDiscovery {
      * @return {string}
      * @constructor
      */
-    static get PROMPT() { return "PROMPT"; }
+    public static readonly PROMPT = AutoDiscoveryAction.PROMPT;
 
     /**
      * The auto discovery was successful.
      * @return {string}
      * @constructor
      */
-    static get SUCCESS() { return "SUCCESS"; }
+    public static readonly SUCCESS = AutoDiscoveryAction.SUCCESS;
 
     /**
      * Validates and verifies client configuration information for purposes
@@ -193,13 +114,13 @@ export class AutoDiscovery {
      * and identity server URL the client would want. Additional details
      * may also be included, and will be transparently brought into the
      * response object unaltered.
-     * @param {string} wellknown The configuration object itself, as returned
+     * @param {object} wellknown The configuration object itself, as returned
      * by the .well-known auto-discovery endpoint.
      * @return {Promise<DiscoveredClientConfig>} Resolves to the verified
      * configuration, which may include error states. Rejects on unexpected
      * failure, not when verification fails.
      */
-    static async fromDiscoveryConfig(wellknown) {
+    public static async fromDiscoveryConfig(wellknown: any): Promise<IClientWellKnown> {
         // Step 1 is to get the config, which is provided to us here.
 
         // We default to an error state to make the first few checks easier to
@@ -240,7 +161,7 @@ export class AutoDiscovery {
 
         // Step 2: Make sure the homeserver URL is valid *looking*. We'll make
         // sure it points to a homeserver in Step 3.
-        const hsUrl = this._sanitizeWellKnownUrl(
+        const hsUrl = this.sanitizeWellKnownUrl(
             wellknown["m.homeserver"]["base_url"],
         );
         if (!hsUrl) {
@@ -250,7 +171,7 @@ export class AutoDiscovery {
         }
 
         // Step 3: Make sure the homeserver URL points to a homeserver.
-        const hsVersions = await this._fetchWellKnownObject(
+        const hsVersions = await this.fetchWellKnownObject(
             `${hsUrl}/_matrix/client/versions`,
         );
         if (!hsVersions || !hsVersions.raw["versions"]) {
@@ -272,7 +193,7 @@ export class AutoDiscovery {
         };
 
         // Step 5: Try to pull out the identity server configuration
-        let isUrl = "";
+        let isUrl: string | boolean = "";
         if (wellknown["m.identity_server"]) {
             // We prepare a failing identity server response to save lines later
             // in this branch.
@@ -287,7 +208,7 @@ export class AutoDiscovery {
 
             // Step 5a: Make sure the URL is valid *looking*. We'll make sure it
             // points to an identity server in Step 5b.
-            isUrl = this._sanitizeWellKnownUrl(
+            isUrl = this.sanitizeWellKnownUrl(
                 wellknown["m.identity_server"]["base_url"],
             );
             if (!isUrl) {
@@ -299,10 +220,10 @@ export class AutoDiscovery {
 
             // Step 5b: Verify there is an identity server listening on the provided
             // URL.
-            const isResponse = await this._fetchWellKnownObject(
+            const isResponse = await this.fetchWellKnownObject(
                 `${isUrl}/_matrix/identity/api/v1`,
             );
-            if (!isResponse || !isResponse.raw || isResponse.action !== "SUCCESS") {
+            if (!isResponse || !isResponse.raw || isResponse.action !== AutoDiscoveryAction.SUCCESS) {
                 logger.error("Invalid /api/v1 response");
                 failingClientConfig["m.identity_server"].error =
                     AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER;
@@ -317,7 +238,7 @@ export class AutoDiscovery {
 
         // Step 6: Now that the identity server is valid, or never existed,
         // populate the IS section.
-        if (isUrl && isUrl.length > 0) {
+        if (isUrl && isUrl.toString().length > 0) {
             clientConfig["m.identity_server"] = {
                 state: AutoDiscovery.SUCCESS,
                 error: null,
@@ -359,7 +280,7 @@ export class AutoDiscovery {
      * configuration, which may include error states. Rejects on unexpected
      * failure, not when discovery fails.
      */
-    static async findClientConfig(domain) {
+    public static async findClientConfig(domain: string): Promise<IClientWellKnown> {
         if (!domain || typeof(domain) !== "string" || domain.length === 0) {
             throw new Error("'domain' must be a string of non-zero length");
         }
@@ -395,13 +316,13 @@ export class AutoDiscovery {
 
         // Step 1: Actually request the .well-known JSON file and make sure it
         // at least has a homeserver definition.
-        const wellknown = await this._fetchWellKnownObject(
+        const wellknown = await this.fetchWellKnownObject(
             `https://${domain}/.well-known/matrix/client`,
         );
-        if (!wellknown || wellknown.action !== "SUCCESS") {
+        if (!wellknown || wellknown.action !== AutoDiscoveryAction.SUCCESS) {
             logger.error("No response or error when parsing .well-known");
             if (wellknown.reason) logger.error(wellknown.reason);
-            if (wellknown.action === "IGNORE") {
+            if (wellknown.action === AutoDiscoveryAction.IGNORE) {
                 clientConfig["m.homeserver"] = {
                     state: AutoDiscovery.PROMPT,
                     error: null,
@@ -427,12 +348,12 @@ export class AutoDiscovery {
      * @returns {Promise<object>} Resolves to the domain's client config. Can
      * be an empty object.
      */
-    static async getRawClientConfig(domain) {
+    public static async getRawClientConfig(domain: string): Promise<IClientWellKnown> {
         if (!domain || typeof(domain) !== "string" || domain.length === 0) {
             throw new Error("'domain' must be a string of non-zero length");
         }
 
-        const response = await this._fetchWellKnownObject(
+        const response = await this.fetchWellKnownObject(
             `https://${domain}/.well-known/matrix/client`,
         );
         if (!response) return {};
@@ -447,7 +368,7 @@ export class AutoDiscovery {
      * @return {string|boolean} The sanitized URL or a falsey value if the URL is invalid.
      * @private
      */
-    static _sanitizeWellKnownUrl(url) {
+    private static sanitizeWellKnownUrl(url: string): string | boolean {
         if (!url) return false;
 
         try {
@@ -495,26 +416,29 @@ export class AutoDiscovery {
      * @return {Promise<object>} Resolves to the returned state.
      * @private
      */
-    static async _fetchWellKnownObject(url) {
+    private static async fetchWellKnownObject(url: string): Promise<IWellKnownConfig> {
         return new Promise(function(resolve, reject) {
+            // eslint-disable-next-line
             const request = require("./matrix").getRequest();
             if (!request) throw new Error("No request library available");
             request(
                 { method: "GET", uri: url, timeout: 5000 },
                 (err, response, body) => {
-                    if (err || response.statusCode < 200 || response.statusCode >= 300) {
-                        let action = "FAIL_PROMPT";
+                    if (err || response &&
+                        (response.statusCode < 200 || response.statusCode >= 300)
+                    ) {
+                        let action = AutoDiscoveryAction.FAIL_PROMPT;
                         let reason = (err ? err.message : null) || "General failure";
-                        if (response.statusCode === 404) {
-                            action = "IGNORE";
+                        if (response && response.statusCode === 404) {
+                            action = AutoDiscoveryAction.IGNORE;
                             reason = AutoDiscovery.ERROR_MISSING_WELLKNOWN;
                         }
-                        resolve({raw: {}, action: action, reason: reason, error: err});
+                        resolve({ raw: {}, action: action, reason: reason, error: err });
                         return;
                     }
 
                     try {
-                        resolve({raw: JSON.parse(body), action: "SUCCESS"});
+                        resolve({ raw: JSON.parse(body), action: AutoDiscoveryAction.SUCCESS });
                     } catch (e) {
                         let reason = AutoDiscovery.ERROR_INVALID;
                         if (e.name === "SyntaxError") {
@@ -522,7 +446,7 @@ export class AutoDiscovery {
                         }
                         resolve({
                             raw: {},
-                            action: "FAIL_PROMPT",
+                            action: AutoDiscoveryAction.FAIL_PROMPT,
                             reason: reason,
                             error: e,
                         });

src/browser-index.js

@@ -34,7 +34,7 @@ matrixcs.request(function(opts, fn) {
 let indexedDB;
 try {
     indexedDB = global.indexedDB;
-} catch(e) {}
+} catch (e) {}
 
 // if our browser (appears to) support indexeddb, use an indexeddb crypto store.
 if (indexedDB) {

src/content-helpers.ts

@@ -1,6 +1,6 @@
 /*
 Copyright 2018 New Vector Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
+Copyright 2018 - 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.
@@ -17,15 +17,17 @@ limitations under the License.
 
 /** @module ContentHelpers */
 
+import { MsgType } from "./@types/event";
+
 /**
  * Generates the content for a HTML Message event
  * @param {string} body the plaintext body of the message
  * @param {string} htmlBody the HTML representation of the message
  * @returns {{msgtype: string, format: string, body: string, formatted_body: string}}
  */
-export function makeHtmlMessage(body, htmlBody) {
+export function makeHtmlMessage(body: string, htmlBody: string) {
     return {
-        msgtype: "m.text",
+        msgtype: MsgType.Text,
         format: "org.matrix.custom.html",
         body: body,
         formatted_body: htmlBody,
@@ -38,9 +40,9 @@ export function makeHtmlMessage(body, htmlBody) {
  * @param {string} htmlBody the HTML representation of the notice
  * @returns {{msgtype: string, format: string, body: string, formatted_body: string}}
  */
-export function makeHtmlNotice(body, htmlBody) {
+export function makeHtmlNotice(body: string, htmlBody: string) {
     return {
-        msgtype: "m.notice",
+        msgtype: MsgType.Notice,
         format: "org.matrix.custom.html",
         body: body,
         formatted_body: htmlBody,
@@ -53,9 +55,9 @@ export function makeHtmlNotice(body, htmlBody) {
  * @param {string} htmlBody the HTML representation of the emote
  * @returns {{msgtype: string, format: string, body: string, formatted_body: string}}
  */
-export function makeHtmlEmote(body, htmlBody) {
+export function makeHtmlEmote(body: string, htmlBody: string) {
     return {
-        msgtype: "m.emote",
+        msgtype: MsgType.Emote,
         format: "org.matrix.custom.html",
         body: body,
         formatted_body: htmlBody,
@@ -67,9 +69,9 @@ export function makeHtmlEmote(body, htmlBody) {
  * @param {string} body the plaintext body of the emote
  * @returns {{msgtype: string, body: string}}
  */
-export function makeTextMessage(body) {
+export function makeTextMessage(body: string) {
     return {
-        msgtype: "m.text",
+        msgtype: MsgType.Text,
         body: body,
     };
 }
@@ -79,9 +81,9 @@ export function makeTextMessage(body) {
  * @param {string} body the plaintext body of the notice
  * @returns {{msgtype: string, body: string}}
  */
-export function makeNotice(body) {
+export function makeNotice(body: string) {
     return {
-        msgtype: "m.notice",
+        msgtype: MsgType.Notice,
         body: body,
     };
 }
@@ -91,9 +93,9 @@ export function makeNotice(body) {
  * @param {string} body the plaintext body of the emote
  * @returns {{msgtype: string, body: string}}
  */
-export function makeEmoteMessage(body) {
+export function makeEmoteMessage(body: string) {
     return {
-        msgtype: "m.emote",
+        msgtype: MsgType.Emote,
         body: body,
     };
 }

src/content-repo.ts

@@ -1,6 +1,5 @@
 /*
-Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
+Copyright 2015 - 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.
@@ -34,8 +33,14 @@ import * as utils from "./utils";
  * for such URLs.
  * @return {string} The complete URL to the content.
  */
-export function getHttpUriForMxc(baseUrl, mxc, width, height,
-                           resizeMethod, allowDirectLinks) {
+export function getHttpUriForMxc(
+    baseUrl: string,
+    mxc: string,
+    width: number,
+    height: number,
+    resizeMethod: string,
+    allowDirectLinks = false,
+): string {
     if (typeof mxc !== "string" || !mxc) {
         return '';
     }
@@ -51,15 +56,15 @@ export function getHttpUriForMxc(baseUrl, mxc, width, height,
     const params = {};
 
     if (width) {
-        params.width = Math.round(width);
+        params["width"] = Math.round(width);
     }
     if (height) {
-        params.height = Math.round(height);
+        params["height"] = Math.round(height);
     }
     if (resizeMethod) {
-        params.method = resizeMethod;
+        params["method"] = resizeMethod;
     }
-    if (utils.keys(params).length > 0) {
+    if (Object.keys(params).length > 0) {
         // these are thumbnailing params so they probably want the
         // thumbnailing API...
         prefix = "/_matrix/media/r0/thumbnail/";
@@ -71,39 +76,7 @@ export function getHttpUriForMxc(baseUrl, mxc, width, height,
         fragment = serverAndMediaId.substr(fragmentOffset);
         serverAndMediaId = serverAndMediaId.substr(0, fragmentOffset);
     }
-    return baseUrl + prefix + serverAndMediaId +
-        (utils.keys(params).length === 0 ? "" :
-        ("?" + utils.encodeParams(params))) + fragment;
-}
 
-/**
- * Get an identicon URL from an arbitrary string.
- * @param {string} baseUrl The base homeserver url which has a content repo.
- * @param {string} identiconString The string to create an identicon for.
- * @param {Number} width The desired width of the image in pixels. Default: 96.
- * @param {Number} height The desired height of the image in pixels. Default: 96.
- * @return {string} The complete URL to the identicon.
- * @deprecated This is no longer in the specification.
- */
-export function getIdenticonUri(baseUrl, identiconString, width, height) {
-    if (!identiconString) {
-        return null;
-    }
-    if (!width) {
-        width = 96;
-    }
-    if (!height) {
-        height = 96;
-    }
-    const params = {
-        width: width,
-        height: height,
-    };
-
-    const path = utils.encodeUri("/_matrix/media/unstable/identicon/$ident", {
-        $ident: identiconString,
-    });
-    return baseUrl + path +
-        (utils.keys(params).length === 0 ? "" :
-            ("?" + utils.encodeParams(params)));
+    const urlParams = (Object.keys(params).length === 0 ? "" : ("?" + utils.encodeParams(params)));
+    return baseUrl + prefix + serverAndMediaId + urlParams + fragment;
 }

src/crypto/CrossSigning.ts

@@ -1,6 +1,5 @@
 /*
-Copyright 2019 New Vector Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
+Copyright 2019 - 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.
@@ -20,19 +19,51 @@ limitations under the License.
  * @module crypto/CrossSigning
  */
 
-import {decodeBase64, encodeBase64, pkSign, pkVerify} from './olmlib';
-import {EventEmitter} from 'events';
-import {logger} from '../logger';
-import {IndexedDBCryptoStore} from '../crypto/store/indexeddb-crypto-store';
+import { EventEmitter } from 'events';
 
-function publicKeyFromKeyInfo(keyInfo) {
+import { decodeBase64, encodeBase64, pkSign, pkVerify } from './olmlib';
+import { logger } from '../logger';
+import { IndexedDBCryptoStore } from '../crypto/store/indexeddb-crypto-store';
+import { decryptAES, encryptAES } from './aes';
+import { PkSigning } from "@matrix-org/olm";
+import { DeviceInfo } from "./deviceinfo";
+import { SecretStorage } from "./SecretStorage";
+import { ICrossSigningKey, ISignedKey, MatrixClient } from "../client";
+import { OlmDevice } from "./OlmDevice";
+import { ICryptoCallbacks } from "../matrix";
+import { ISignatures } from "../@types/signed";
+import { CryptoStore } from "./store/base";
+
+const KEY_REQUEST_TIMEOUT_MS = 1000 * 60;
+
+function publicKeyFromKeyInfo(keyInfo: ICrossSigningKey): string {
     // `keys` is an object with { [`ed25519:${pubKey}`]: pubKey }
     // We assume only a single key, and we want the bare form without type
     // prefix, so we select the values.
     return Object.values(keyInfo.keys)[0];
 }
 
+export interface ICacheCallbacks {
+    getCrossSigningKeyCache?(type: string, expectedPublicKey?: string): Promise<Uint8Array>;
+    storeCrossSigningKeyCache?(type: string, key: Uint8Array): Promise<void>;
+}
+
+export interface ICrossSigningInfo {
+    keys: Record<string, ICrossSigningKey>;
+    firstUse: boolean;
+    crossSigningVerifiedBefore: boolean;
+}
+
 export class CrossSigningInfo extends EventEmitter {
+    public keys: Record<string, ICrossSigningKey> = {};
+    public firstUse = true;
+    // This tracks whether we've ever verified this user with any identity.
+    // When you verify a user, any devices online at the time that receive
+    // the verifying signature via the homeserver will latch this to true
+    // and can use it in the future to detect cases where the user has
+    // become unverified later for any reason.
+    private crossSigningVerifiedBefore = false;
+
     /**
      * Information about a user's cross-signing keys
      *
@@ -43,31 +74,44 @@ export class CrossSigningInfo extends EventEmitter {
      *     Requires getCrossSigningKey and saveCrossSigningKeys
      * @param {object} cacheCallbacks Callbacks used to interact with the cache
      */
-    constructor(userId, callbacks, cacheCallbacks) {
+    constructor(
+        public readonly userId: string,
+        private callbacks: ICryptoCallbacks = {},
+        private cacheCallbacks: ICacheCallbacks = {},
+    ) {
         super();
+    }
 
-        // you can't change the userId
-        Object.defineProperty(this, 'userId', {
-            enumerable: true,
-            value: userId,
-        });
-        this._callbacks = callbacks || {};
-        this._cacheCallbacks = cacheCallbacks || {};
-        this.keys = {};
-        this.firstUse = true;
+    public static fromStorage(obj: ICrossSigningInfo, userId: string): CrossSigningInfo {
+        const res = new CrossSigningInfo(userId);
+        for (const prop in obj) {
+            if (obj.hasOwnProperty(prop)) {
+                res[prop] = obj[prop];
+            }
+        }
+        return res;
+    }
+
+    public toStorage(): ICrossSigningInfo {
+        return {
+            keys: this.keys,
+            firstUse: this.firstUse,
+            crossSigningVerifiedBefore: this.crossSigningVerifiedBefore,
+        };
     }
 
     /**
      * Calls the app callback to ask for a private key
+     *
      * @param {string} type The key type ("master", "self_signing", or "user_signing")
      * @param {string} expectedPubkey The matching public key or undefined to use
      *     the stored public key for the given key type.
      * @returns {Array} An array with [ public key, Olm.PkSigning ]
      */
-    async getCrossSigningKey(type, expectedPubkey) {
-        const shouldCache = ["self_signing", "user_signing"].indexOf(type) >= 0;
+    public async getCrossSigningKey(type: string, expectedPubkey?: string): Promise<[string, PkSigning]> {
+        const shouldCache = ["master", "self_signing", "user_signing"].indexOf(type) >= 0;
 
-        if (!this._callbacks.getCrossSigningKey) {
+        if (!this.callbacks.getCrossSigningKey) {
             throw new Error("No getCrossSigningKey callback supplied");
         }
 
@@ -75,7 +119,7 @@ export class CrossSigningInfo extends EventEmitter {
             expectedPubkey = this.getId(type);
         }
 
-        function validateKey(key) {
+        function validateKey(key: Uint8Array): [string, PkSigning] {
             if (!key) return;
             const signing = new global.Olm.PkSigning();
             const gotPubkey = signing.init_with_seed(key);
@@ -86,9 +130,8 @@ export class CrossSigningInfo extends EventEmitter {
         }
 
         let privkey;
-        if (this._cacheCallbacks.getCrossSigningKeyCache && shouldCache) {
-            privkey = await this._cacheCallbacks
-              .getCrossSigningKeyCache(type, expectedPubkey);
+        if (this.cacheCallbacks.getCrossSigningKeyCache && shouldCache) {
+            privkey = await this.cacheCallbacks.getCrossSigningKeyCache(type, expectedPubkey);
         }
 
         const cacheresult = validateKey(privkey);
@@ -96,11 +139,11 @@ export class CrossSigningInfo extends EventEmitter {
             return cacheresult;
         }
 
-        privkey = await this._callbacks.getCrossSigningKey(type, expectedPubkey);
+        privkey = await this.callbacks.getCrossSigningKey(type, expectedPubkey);
         const result = validateKey(privkey);
         if (result) {
-            if (this._cacheCallbacks.storeCrossSigningKeyCache && shouldCache) {
-                await this._cacheCallbacks.storeCrossSigningKeyCache(type, privkey);
+            if (this.cacheCallbacks.storeCrossSigningKeyCache && shouldCache) {
+                await this.cacheCallbacks.storeCrossSigningKeyCache(type, privkey);
             }
             return result;
         }
@@ -118,23 +161,6 @@ export class CrossSigningInfo extends EventEmitter {
         );
     }
 
-    static fromStorage(obj, userId) {
-        const res = new CrossSigningInfo(userId);
-        for (const prop in obj) {
-            if (obj.hasOwnProperty(prop)) {
-                res[prop] = obj[prop];
-            }
-        }
-        return res;
-    }
-
-    toStorage() {
-        return {
-            keys: this.keys,
-            firstUse: this.firstUse,
-        };
-    }
-
     /**
      * Check whether the private keys exist in secret storage.
      * XXX: This could be static, be we often seem to have an instance when we
@@ -145,10 +171,9 @@ export class CrossSigningInfo extends EventEmitter {
      *     with, or null if it is not present or not encrypted with a trusted
      *     key
      */
-    async isStoredInSecretStorage(secretStorage) {
+    public async isStoredInSecretStorage(secretStorage: SecretStorage): Promise<Record<string, object>> {
         // check what SSSS keys have encrypted the master key (if any)
-        const stored =
-              await secretStorage.isStored("m.cross_signing.master", false) || {};
+        const stored = await secretStorage.isStored("m.cross_signing.master", false) || {};
         // then check which of those SSSS keys have also encrypted the SSK and USK
         function intersect(s) {
             for (const k of Object.keys(stored)) {
@@ -158,9 +183,7 @@ export class CrossSigningInfo extends EventEmitter {
             }
         }
         for (const type of ["self_signing", "user_signing"]) {
-            intersect(
-                await secretStorage.isStored(`m.cross_signing.${type}`, false) || {},
-            );
+            intersect(await secretStorage.isStored(`m.cross_signing.${type}`, false) || {});
         }
         return Object.keys(stored).length ? stored : null;
     }
@@ -170,12 +193,15 @@ export class CrossSigningInfo extends EventEmitter {
      * typically called in conjunction with the creation of new cross-signing
      * keys.
      *
-     * @param {object} keys The keys to store
+     * @param {Map} keys The keys to store
      * @param {SecretStorage} secretStorage The secret store using account data
      */
-    static async storeInSecretStorage(keys, secretStorage) {
-        for (const type of Object.keys(keys)) {
-            const encodedKey = encodeBase64(keys[type]);
+    public static async storeInSecretStorage(
+        keys: Map<string, Uint8Array>,
+        secretStorage: SecretStorage,
+    ): Promise<void> {
+        for (const [type, privateKey] of keys) {
+            const encodedKey = encodeBase64(privateKey);
             await secretStorage.store(`m.cross_signing.${type}`, encodedKey);
         }
     }
@@ -189,11 +215,52 @@ export class CrossSigningInfo extends EventEmitter {
      * @param {SecretStorage} secretStorage The secret store using account data
      * @return {Uint8Array} The private key
      */
-    static async getFromSecretStorage(type, secretStorage) {
+    public static async getFromSecretStorage(type: string, secretStorage: SecretStorage): Promise<Uint8Array> {
         const encodedKey = await secretStorage.get(`m.cross_signing.${type}`);
+        if (!encodedKey) {
+            return null;
+        }
         return decodeBase64(encodedKey);
     }
 
+    /**
+     * Check whether the private keys exist in the local key cache.
+     *
+     * @param {string} [type] The type of key to get. One of "master",
+     * "self_signing", or "user_signing". Optional, will check all by default.
+     * @returns {boolean} True if all keys are stored in the local cache.
+     */
+    public async isStoredInKeyCache(type?: string): Promise<boolean> {
+        const cacheCallbacks = this.cacheCallbacks;
+        if (!cacheCallbacks) return false;
+        const types = type ? [type] : ["master", "self_signing", "user_signing"];
+        for (const t of types) {
+            if (!await cacheCallbacks.getCrossSigningKeyCache(t)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Get cross-signing private keys from the local cache.
+     *
+     * @returns {Map} A map from key type (string) to private key (Uint8Array)
+     */
+    public async getCrossSigningKeysFromCache(): Promise<Map<string, Uint8Array>> {
+        const keys = new Map();
+        const cacheCallbacks = this.cacheCallbacks;
+        if (!cacheCallbacks) return keys;
+        for (const type of ["master", "self_signing", "user_signing"]) {
+            const privKey = await cacheCallbacks.getCrossSigningKeyCache(type);
+            if (!privKey) {
+                continue;
+            }
+            keys.set(type, privKey);
+        }
+        return keys;
+    }
+
     /**
      * Get the ID used to identify the user. This can also be used to test for
      * the existence of a given key type.
@@ -203,8 +270,7 @@ export class CrossSigningInfo extends EventEmitter {
      *
      * @return {string} the ID
      */
-    getId(type) {
-        type = type || "master";
+    public getId(type = "master"): string {
         if (!this.keys[type]) return null;
         const keyInfo = this.keys[type];
         return publicKeyFromKeyInfo(keyInfo);
@@ -217,8 +283,8 @@ export class CrossSigningInfo extends EventEmitter {
      *
      * @param {CrossSigningLevel} level The key types to reset
      */
-    async resetKeys(level) {
-        if (!this._callbacks.saveCrossSigningKeys) {
+    public async resetKeys(level?: CrossSigningLevel): Promise<void> {
+        if (!this.callbacks.saveCrossSigningKeys) {
             throw new Error("No saveCrossSigningKeys callback supplied");
         }
 
@@ -233,12 +299,12 @@ export class CrossSigningInfo extends EventEmitter {
                 CrossSigningLevel.USER_SIGNING |
                 CrossSigningLevel.SELF_SIGNING
             );
-        } else if (level === 0) {
+        } else if (level === 0 as CrossSigningLevel) {
             return;
         }
 
-        const privateKeys = {};
-        const keys = {};
+        const privateKeys: Record<string, Uint8Array> = {};
+        const keys: Record<string, any> = {}; // TODO types
         let masterSigning;
         let masterPub;
 
@@ -295,7 +361,7 @@ export class CrossSigningInfo extends EventEmitter {
             }
 
             Object.assign(this.keys, keys);
-            this._callbacks.saveCrossSigningKeys(privateKeys);
+            this.callbacks.saveCrossSigningKeys(privateKeys);
         } finally {
             if (masterSigning) {
                 masterSigning.free();
@@ -303,8 +369,15 @@ export class CrossSigningInfo extends EventEmitter {
         }
     }
 
-    setKeys(keys) {
-        const signingKeys = {};
+    /**
+     * unsets the keys, used when another session has reset the keys, to disable cross-signing
+     */
+    public clearKeys(): void {
+        this.keys = {};
+    }
+
+    public setKeys(keys: Record<string, ICrossSigningKey>): void {
+        const signingKeys: Record<string, ICrossSigningKey> = {};
         if (keys.master) {
             if (keys.master.user_id !== this.userId) {
                 const error = "Mismatched user ID " + keys.master.user_id +
@@ -375,7 +448,15 @@ export class CrossSigningInfo extends EventEmitter {
         }
     }
 
-    async signObject(data, type) {
+    public updateCrossSigningVerifiedBefore(isCrossSigningVerified: boolean): void {
+        // It is critical that this value latches forward from false to true but
+        // never back to false to avoid a downgrade attack.
+        if (!this.crossSigningVerifiedBefore && isCrossSigningVerified) {
+            this.crossSigningVerifiedBefore = true;
+        }
+    }
+
+    public async signObject<T extends object>(data: T, type: string): Promise<T & { signatures: ISignatures }> {
         if (!this.keys[type]) {
             throw new Error(
                 "Attempted to sign with " + type + " key but no such key present",
@@ -384,13 +465,13 @@ export class CrossSigningInfo extends EventEmitter {
         const [pubkey, signing] = await this.getCrossSigningKey(type);
         try {
             pkSign(data, signing, this.userId, pubkey);
-            return data;
+            return data as T & { signatures: ISignatures };
         } finally {
             signing.free();
         }
     }
 
-    async signUser(key) {
+    public async signUser(key: CrossSigningInfo): Promise<ICrossSigningKey> {
         if (!this.keys.user_signing) {
             logger.info("No user signing key: not signing user");
             return;
@@ -398,7 +479,7 @@ export class CrossSigningInfo extends EventEmitter {
         return this.signObject(key.keys.master, "user_signing");
     }
 
-    async signDevice(userId, device) {
+    public async signDevice(userId: string, device: DeviceInfo): Promise<ISignedKey> {
         if (userId !== this.userId) {
             throw new Error(
                 `Trying to sign ${userId}'s device; can only sign our own device`,
@@ -408,7 +489,7 @@ export class CrossSigningInfo extends EventEmitter {
             logger.info("No self signing key: not signing device");
             return;
         }
-        return this.signObject(
+        return this.signObject<Omit<ISignedKey, "signatures">>(
             {
                 algorithms: device.algorithms,
                 keys: device.keys,
@@ -425,7 +506,7 @@ export class CrossSigningInfo extends EventEmitter {
      *
      * @returns {UserTrustLevel}
      */
-    checkUserTrust(userCrossSigning) {
+    public checkUserTrust(userCrossSigning: CrossSigningInfo): UserTrustLevel {
         // if we're checking our own key, then it's trusted if the master key
         // and self-signing key match
         if (this.userId === userCrossSigning.userId
@@ -433,13 +514,13 @@ export class CrossSigningInfo extends EventEmitter {
             && this.getId("self_signing")
             && this.getId("self_signing") === userCrossSigning.getId("self_signing")
         ) {
-            return new UserTrustLevel(true, this.firstUse);
+            return new UserTrustLevel(true, true, this.firstUse);
         }
 
         if (!this.keys.user_signing) {
             // If there's no user signing key, they can't possibly be verified.
             // They may be TOFU trusted though.
-            return new UserTrustLevel(false, userCrossSigning.firstUse);
+            return new UserTrustLevel(false, false, userCrossSigning.firstUse);
         }
 
         let userTrusted;
@@ -451,7 +532,11 @@ export class CrossSigningInfo extends EventEmitter {
         } catch (e) {
             userTrusted = false;
         }
-        return new UserTrustLevel(userTrusted, userCrossSigning.firstUse);
+        return new UserTrustLevel(
+            userTrusted,
+            userCrossSigning.crossSigningVerifiedBefore,
+            userCrossSigning.firstUse,
+        );
     }
 
     /**
@@ -459,12 +544,17 @@ export class CrossSigningInfo extends EventEmitter {
      *
      * @param {CrossSigningInfo} userCrossSigning Cross signing info for user
      * @param {module:crypto/deviceinfo} device The device to check
-     * @param {bool} localTrust Whether the device is trusted locally
-     * @param {bool} trustCrossSignedDevices Whether we trust cross signed devices
+     * @param {boolean} localTrust Whether the device is trusted locally
+     * @param {boolean} trustCrossSignedDevices Whether we trust cross signed devices
      *
      * @returns {DeviceTrustLevel}
      */
-    checkDeviceTrust(userCrossSigning, device, localTrust, trustCrossSignedDevices) {
+    public checkDeviceTrust(
+        userCrossSigning: CrossSigningInfo,
+        device: DeviceInfo,
+        localTrust: boolean,
+        trustCrossSignedDevices: boolean,
+    ): DeviceTrustLevel {
         const userTrust = this.checkUserTrust(userCrossSigning);
 
         const userSSK = userCrossSigning.keys.self_signing;
@@ -481,29 +571,23 @@ export class CrossSigningInfo extends EventEmitter {
             // if we can verify the user's SSK from their master key...
             pkVerify(userSSK, userCrossSigning.getId(), userCrossSigning.userId);
             // ...and this device's key from their SSK...
-            pkVerify(
-                deviceObj, publicKeyFromKeyInfo(userSSK), userCrossSigning.userId,
-            );
+            pkVerify(deviceObj, publicKeyFromKeyInfo(userSSK), userCrossSigning.userId);
             // ...then we trust this device as much as far as we trust the user
-            return DeviceTrustLevel.fromUserTrustLevel(
-                userTrust, localTrust, trustCrossSignedDevices,
-            );
+            return DeviceTrustLevel.fromUserTrustLevel(userTrust, localTrust, trustCrossSignedDevices);
         } catch (e) {
-            return new DeviceTrustLevel(
-                false, false, localTrust, trustCrossSignedDevices,
-            );
+            return new DeviceTrustLevel(false, false, localTrust, trustCrossSignedDevices);
         }
     }
 
     /**
      * @returns {object} Cache callbacks
      */
-    getCacheCallbacks() {
-        return this._cacheCallbacks;
+    public getCacheCallbacks(): ICacheCallbacks {
+        return this.cacheCallbacks;
     }
 }
 
-function deviceToObject(device, userId) {
+function deviceToObject(device: DeviceInfo, userId: string) {
     return {
         algorithms: device.algorithms,
         keys: device.keys,
@@ -513,40 +597,49 @@ function deviceToObject(device, userId) {
     };
 }
 
-export const CrossSigningLevel = {
-    MASTER: 4,
-    USER_SIGNING: 2,
-    SELF_SIGNING: 1,
-};
+export enum CrossSigningLevel {
+    MASTER = 4,
+    USER_SIGNING = 2,
+    SELF_SIGNING = 1,
+}
 
 /**
  * Represents the ways in which we trust a user
  */
 export class UserTrustLevel {
-    constructor(crossSigningVerified, tofu) {
-        this._crossSigningVerified = crossSigningVerified;
-        this._tofu = tofu;
-    }
+    constructor(
+        private readonly crossSigningVerified: boolean,
+        private readonly crossSigningVerifiedBefore: boolean,
+        private readonly tofu: boolean,
+    ) {}
 
     /**
-     * @returns {bool} true if this user is verified via any means
+     * @returns {boolean} true if this user is verified via any means
      */
-    isVerified() {
+    public isVerified(): boolean {
         return this.isCrossSigningVerified();
     }
 
     /**
-     * @returns {bool} true if this user is verified via cross signing
+     * @returns {boolean} true if this user is verified via cross signing
      */
-    isCrossSigningVerified() {
-        return this._crossSigningVerified;
+    public isCrossSigningVerified(): boolean {
+        return this.crossSigningVerified;
     }
 
     /**
-     * @returns {bool} true if this user's key is trusted on first use
+     * @returns {boolean} true if we ever verified this user before (at least for
+     * the history of verifications observed by this device).
      */
-    isTofu() {
-        return this._tofu;
+    public wasCrossSigningVerified(): boolean {
+        return this.crossSigningVerifiedBefore;
+    }
+
+    /**
+     * @returns {boolean} true if this user's key is trusted on first use
+     */
+    public isTofu(): boolean {
+        return this.tofu;
     }
 }
 
@@ -554,58 +647,62 @@ export class UserTrustLevel {
  * Represents the ways in which we trust a device
  */
 export class DeviceTrustLevel {
-    constructor(crossSigningVerified, tofu, localVerified, trustCrossSignedDevices) {
-        this._crossSigningVerified = crossSigningVerified;
-        this._tofu = tofu;
-        this._localVerified = localVerified;
-        this._trustCrossSignedDevices = trustCrossSignedDevices;
-    }
+    constructor(
+        public readonly crossSigningVerified: boolean,
+        public readonly tofu: boolean,
+        private readonly localVerified: boolean,
+        private readonly trustCrossSignedDevices: boolean,
+    ) {}
 
-    static fromUserTrustLevel(userTrustLevel, localVerified, trustCrossSignedDevices) {
+    public static fromUserTrustLevel(
+        userTrustLevel: UserTrustLevel,
+        localVerified: boolean,
+        trustCrossSignedDevices: boolean,
+    ): DeviceTrustLevel {
         return new DeviceTrustLevel(
-            userTrustLevel._crossSigningVerified,
-            userTrustLevel._tofu,
+            userTrustLevel.isCrossSigningVerified(),
+            userTrustLevel.isTofu(),
             localVerified,
             trustCrossSignedDevices,
         );
     }
 
     /**
-     * @returns {bool} true if this device is verified via any means
+     * @returns {boolean} true if this device is verified via any means
      */
-    isVerified() {
+    public isVerified(): boolean {
         return Boolean(this.isLocallyVerified() || (
-            this._trustCrossSignedDevices && this.isCrossSigningVerified()
+            this.trustCrossSignedDevices && this.isCrossSigningVerified()
         ));
     }
 
     /**
-     * @returns {bool} true if this device is verified via cross signing
+     * @returns {boolean} true if this device is verified via cross signing
      */
-    isCrossSigningVerified() {
-        return this._crossSigningVerified;
+    public isCrossSigningVerified(): boolean {
+        return this.crossSigningVerified;
     }
 
     /**
-     * @returns {bool} true if this device is verified locally
+     * @returns {boolean} true if this device is verified locally
      */
-    isLocallyVerified() {
-        return this._localVerified;
+    public isLocallyVerified(): boolean {
+        return this.localVerified;
     }
 
     /**
-     * @returns {bool} true if this device is trusted from a user's key
+     * @returns {boolean} true if this device is trusted from a user's key
      * that is trusted on first use
      */
-    isTofu() {
-        return this._tofu;
+    public isTofu(): boolean {
+        return this.tofu;
     }
 }
 
-export function createCryptoStoreCacheCallbacks(store) {
+export function createCryptoStoreCacheCallbacks(store: CryptoStore, olmDevice: OlmDevice): ICacheCallbacks {
     return {
-        getCrossSigningKeyCache: function(type, _expectedPublicKey) {
-            return new Promise((resolve) => {
+        getCrossSigningKeyCache: async function(type: string, _expectedPublicKey: string): Promise<Uint8Array> {
+            const key = await new Promise<any>((resolve) => {
                 return store.doTxn(
                     'readonly',
                     [IndexedDBCryptoStore.STORE_ACCOUNT],
@@ -614,15 +711,125 @@ export function createCryptoStoreCacheCallbacks(store) {
                     },
                 );
             });
+
+            if (key && key.ciphertext) {
+                const pickleKey = Buffer.from(olmDevice.pickleKey);
+                const decrypted = await decryptAES(key, pickleKey, type);
+                return decodeBase64(decrypted);
+            } else {
+                return key;
+            }
         },
-        storeCrossSigningKeyCache: function(type, key) {
+        storeCrossSigningKeyCache: async function(type: string, key: Uint8Array): Promise<void> {
+            if (!(key instanceof Uint8Array)) {
+                throw new Error(
+                    `storeCrossSigningKeyCache expects Uint8Array, got ${key}`,
+                );
+            }
+            const pickleKey = Buffer.from(olmDevice.pickleKey);
+            const encryptedKey = await encryptAES(encodeBase64(key), pickleKey, type);
             return store.doTxn(
                 'readwrite',
                 [IndexedDBCryptoStore.STORE_ACCOUNT],
                 (txn) => {
-                    store.storeSecretStorePrivateKey(txn, type, key);
+                    store.storeSecretStorePrivateKey(txn, type, encryptedKey);
                 },
             );
         },
     };
 }
+
+export type KeysDuringVerification = [[string, PkSigning], [string, PkSigning], [string, PkSigning], void];
+
+/**
+ * Request cross-signing keys from another device during verification.
+ *
+ * @param {MatrixClient} baseApis base Matrix API interface
+ * @param {string} userId The user ID being verified
+ * @param {string} deviceId The device ID being verified
+ */
+export function requestKeysDuringVerification(
+    baseApis: MatrixClient,
+    userId: string,
+    deviceId: string,
+): Promise<KeysDuringVerification | void> {
+    // If this is a self-verification, ask the other party for keys
+    if (baseApis.getUserId() !== userId) {
+        return;
+    }
+    logger.log("Cross-signing: Self-verification done; requesting keys");
+    // This happens asynchronously, and we're not concerned about waiting for
+    // it. We return here in order to test.
+    return new Promise<KeysDuringVerification | void>((resolve, reject) => {
+        const client = baseApis;
+        const original = client.crypto.crossSigningInfo;
+
+        // We already have all of the infrastructure we need to validate and
+        // cache cross-signing keys, so instead of replicating that, here we set
+        // up callbacks that request them from the other device and call
+        // CrossSigningInfo.getCrossSigningKey() to validate/cache
+        const crossSigning = new CrossSigningInfo(
+            original.userId,
+            { getCrossSigningKey: async (type) => {
+                logger.debug("Cross-signing: requesting secret", type, deviceId);
+                const { promise } = client.requestSecret(
+                    `m.cross_signing.${type}`, [deviceId],
+                );
+                const result = await promise;
+                const decoded = decodeBase64(result);
+                return Uint8Array.from(decoded);
+            } },
+            original.getCacheCallbacks(),
+        );
+        crossSigning.keys = original.keys;
+
+        // XXX: get all keys out if we get one key out
+        // https://github.com/vector-im/element-web/issues/12604
+        // then change here to reject on the timeout
+        // Requests can be ignored, so don't wait around forever
+        const timeout = new Promise<void>((resolve) => {
+            setTimeout(
+                resolve,
+                KEY_REQUEST_TIMEOUT_MS,
+                new Error("Timeout"),
+            );
+        });
+
+        // also request and cache the key backup key
+        const backupKeyPromise = (async () => {
+            const cachedKey = await client.crypto.getSessionBackupPrivateKey();
+            if (!cachedKey) {
+                logger.info("No cached backup key found. Requesting...");
+                const secretReq = client.requestSecret(
+                    'm.megolm_backup.v1', [deviceId],
+                );
+                const base64Key = await secretReq.promise;
+                logger.info("Got key backup key, decoding...");
+                const decodedKey = decodeBase64(base64Key);
+                logger.info("Decoded backup key, storing...");
+                await client.crypto.storeSessionBackupPrivateKey(
+                    Uint8Array.from(decodedKey),
+                );
+                logger.info("Backup key stored. Starting backup restore...");
+                const backupInfo = await client.getKeyBackupVersion();
+                // no need to await for this - just let it go in the bg
+                client.restoreKeyBackupWithCache(undefined, undefined, backupInfo).then(() => {
+                    logger.info("Backup restored.");
+                });
+            }
+        })();
+
+        // We call getCrossSigningKey() for its side-effects
+        return Promise.race<KeysDuringVerification | void>([
+            Promise.all([
+                crossSigning.getCrossSigningKey("master"),
+                crossSigning.getCrossSigningKey("self_signing"),
+                crossSigning.getCrossSigningKey("user_signing"),
+                backupKeyPromise,
+            ]) as Promise<KeysDuringVerification>,
+            timeout,
+        ]).then(resolve, reject);
+    }).catch((e) => {
+        logger.warn("Cross-signing: failure while requesting keys:", e);
+    });
+}