v11.2.0

Prepare changelog for v11.2.0
v11.2.0-rc.1
2021-06-07 16:57:42 +01:00 · 2021-06-07 16:57:42 +01:00 · 2021-06-01 16:09:49 +01:00 · 2021-06-01 16:09:48 +01:00 · 2021-06-01 12:07:25 +01:00 · 2021-06-01 11:01:10 +01:00
134 changed files with 8833 additions and 6287 deletions
@@ -1,13 +1,14 @@
 module.exports = {
-    extends: ["matrix-org"],
    plugins: [
-        "babel",
+        "matrix-org",
+    ],
+    extends: [
+        "plugin:matrix-org/babel",
    ],
    env: {
        browser: true,
        node: true,
    },
-
    rules: {
        "no-var": ["warn"],
        "prefer-rest-params": ["warn"],
@@ -32,12 +33,26 @@ module.exports = {
        "no-console": "error",
    },
    overrides: [{
-        "files": ["src/**/*.ts"],
-        "extends": ["matrix-org/ts"],
-        "rules": {
-            // While we're converting to ts we make heavy use of this
+        files: [
+            "**/*.ts",
+        ],
+        extends: [
+            "plugin:matrix-org/typescript",
+        ],
+        rules: {
+            // TypeScript has its own version of this
+            "@babel/no-invalid-this": "off",
+
+            // We're okay being explicit at the moment
+            "@typescript-eslint/no-empty-interface": "off",
+            // We disable this while we're transitioning
            "@typescript-eslint/no-explicit-any": "off",
+            // We'd rather not do this but we do
+            "@typescript-eslint/ban-ts-comment": "off",
+
            "quotes": "off",
+            // We use a `logger` intermediary module
+            "no-console": "error",
        },
    }],
 };
@@ -12,7 +12,6 @@ lib-cov
 out
 /dist
 /lib
-/specbuild

 # version file and tarball created by `npm pack` / `yarn pack`
 /git-revision.txt
@@ -1,3 +1,559 @@
+Changes in [11.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0) (2021-06-07)
+==================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.2.0-rc.1...v11.2.0)
+
+ * No changes since rc.1
+
+Changes in [11.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0-rc.1) (2021-06-01)
+============================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.1.0...v11.2.0-rc.1)
+
+ * Switch to stable endpoint/fields for MSC2858
+   [\#1720](https://github.com/matrix-org/matrix-js-sdk/pull/1720)
+ * Bump ws from 7.4.2 to 7.4.6
+   [\#1715](https://github.com/matrix-org/matrix-js-sdk/pull/1715)
+ * Make consistent call event type checks
+   [\#1712](https://github.com/matrix-org/matrix-js-sdk/pull/1712)
+ * Apply new Babel linting config
+   [\#1714](https://github.com/matrix-org/matrix-js-sdk/pull/1714)
+ * Bump browserslist from 4.16.1 to 4.16.6
+   [\#1709](https://github.com/matrix-org/matrix-js-sdk/pull/1709)
+ * Add user_busy call hangup reason
+   [\#1713](https://github.com/matrix-org/matrix-js-sdk/pull/1713)
+ * 👕 New linting rules
+   [\#1688](https://github.com/matrix-org/matrix-js-sdk/pull/1688)
+ * Emit relations created when target event added later
+   [\#1710](https://github.com/matrix-org/matrix-js-sdk/pull/1710)
+ * Bump libolm version and update package name.
+   [\#1705](https://github.com/matrix-org/matrix-js-sdk/pull/1705)
+ * Fix uploadContent not rejecting promise when http status code >= 400
+   [\#1703](https://github.com/matrix-org/matrix-js-sdk/pull/1703)
+ * Reduce noise in tests
+   [\#1702](https://github.com/matrix-org/matrix-js-sdk/pull/1702)
+ * Only log once if a Room lacks an m.room.create event
+   [\#1700](https://github.com/matrix-org/matrix-js-sdk/pull/1700)
+ * Cache normalized room name
+   [\#1701](https://github.com/matrix-org/matrix-js-sdk/pull/1701)
+ * Change call event handlers to adapt to undecrypted events
+   [\#1698](https://github.com/matrix-org/matrix-js-sdk/pull/1698)
+
+Changes in [11.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0) (2021-05-24)
+==================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.1.0-rc.1...v11.1.0)
+
+ * [Release] Bump libolm version and update package name
+   [\#1707](https://github.com/matrix-org/matrix-js-sdk/pull/1707)
+ * [Release] Change call event handlers to adapt to undecrypted events
+   [\#1699](https://github.com/matrix-org/matrix-js-sdk/pull/1699)
+
+Changes in [11.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0-rc.1) (2021-05-19)
+============================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.0.0...v11.1.0-rc.1)
+
+ * Fix regressed glare
+   [\#1690](https://github.com/matrix-org/matrix-js-sdk/pull/1690)
+ * Add m.reaction to EventType enum
+   [\#1692](https://github.com/matrix-org/matrix-js-sdk/pull/1692)
+ * Prioritise and reduce the amount of events decrypted on application startup
+   [\#1684](https://github.com/matrix-org/matrix-js-sdk/pull/1684)
+ * Decrypt relations before applying them to target event
+   [\#1696](https://github.com/matrix-org/matrix-js-sdk/pull/1696)
+ * Guard against duplicates in `Relations` model
+
+Changes in [11.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0) (2021-05-17)
+==================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.0.0-rc.1...v11.0.0)
+
+ * [Release] Fix regressed glare
+   [\#1695](https://github.com/matrix-org/matrix-js-sdk/pull/1695)
+
+Changes in [11.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0-rc.1) (2021-05-11)
+============================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.1.0...v11.0.0-rc.1)
+
+BREAKING CHANGES
+---
+
+ * `MatrixCall` and related APIs have been redesigned to support multiple streams 
+   (see [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660) for more details)
+
+All changes
+---
+
+ * Switch from MSC1772 unstable prefixes to stable
+   [\#1679](https://github.com/matrix-org/matrix-js-sdk/pull/1679)
+ * Update the VoIP example to work with the new changes
+   [\#1680](https://github.com/matrix-org/matrix-js-sdk/pull/1680)
+ * Bump hosted-git-info from 2.8.8 to 2.8.9
+   [\#1687](https://github.com/matrix-org/matrix-js-sdk/pull/1687)
+ * Support for multiple streams (not MSC3077)
+   [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660)
+ * Tweak missing m.room.create errors to describe their source
+   [\#1683](https://github.com/matrix-org/matrix-js-sdk/pull/1683)
+
+Changes in [10.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0) (2021-05-10)
+==================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.1.0-rc.1...v10.1.0)
+
+ * No changes since rc.1
+
+Changes in [10.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0-rc.1) (2021-05-04)
+============================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.0.0...v10.1.0-rc.1)
+
+ * Revert "Raise logging dramatically to chase pending event errors"
+   [\#1681](https://github.com/matrix-org/matrix-js-sdk/pull/1681)
+ * Add test coverage collection script
+   [\#1677](https://github.com/matrix-org/matrix-js-sdk/pull/1677)
+ * Raise logging dramatically to chase pending event errors
+   [\#1678](https://github.com/matrix-org/matrix-js-sdk/pull/1678)
+ * Support MSC3086 asserted identity
+   [\#1674](https://github.com/matrix-org/matrix-js-sdk/pull/1674)
+ * Fix `/search` with no results field work again
+   [\#1670](https://github.com/matrix-org/matrix-js-sdk/pull/1670)
+ * Add room.getMembers method
+   [\#1672](https://github.com/matrix-org/matrix-js-sdk/pull/1672)
+
+Changes in [10.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0) (2021-04-26)
+==================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.0.0-rc.1...v10.0.0)
+
+ * No changes since rc.1
+
+Changes in [10.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0-rc.1) (2021-04-21)
+============================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.11.0...v10.0.0-rc.1)
+
+BREAKING CHANGES
+---
+
+ * The `RoomState.members` event is now only emitted when the room member's power level or the room's normal power level actually changes
+
+All changes
+---
+
+ * Restrict event emit for room members that had power levels changed
+   [\#1675](https://github.com/matrix-org/matrix-js-sdk/pull/1675)
+ * Fix sync with misconfigured push rules
+   [\#1669](https://github.com/matrix-org/matrix-js-sdk/pull/1669)
+ * Add missing await
+   [\#1665](https://github.com/matrix-org/matrix-js-sdk/pull/1665)
+ * Migrate to `eslint-plugin-matrix-org`
+   [\#1642](https://github.com/matrix-org/matrix-js-sdk/pull/1642)
+ * Add missing event type enum for key verification done
+   [\#1664](https://github.com/matrix-org/matrix-js-sdk/pull/1664)
+ * Fix timeline jumpiness by setting correct txnId
+   [\#1663](https://github.com/matrix-org/matrix-js-sdk/pull/1663)
+ * Fix calling addEventListener if it does not exist
+   [\#1661](https://github.com/matrix-org/matrix-js-sdk/pull/1661)
+ * Persist unsent messages for subsequent sessions
+   [\#1655](https://github.com/matrix-org/matrix-js-sdk/pull/1655)
+
+Changes in [9.11.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0) (2021-04-12)
+==================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.11.0-rc.1...v9.11.0)
+
+ * No changes since rc.1
+
+Changes in [9.11.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0-rc.1) (2021-04-07)
+============================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.10.0...v9.11.0-rc.1)
+
+ * Only try to cache private keys we know exist
+   [\#1657](https://github.com/matrix-org/matrix-js-sdk/pull/1657)
+ * Properly terminate screen-share calls if NoUserMedia
+   [\#1654](https://github.com/matrix-org/matrix-js-sdk/pull/1654)
+ * Attended transfer
+   [\#1652](https://github.com/matrix-org/matrix-js-sdk/pull/1652)
+ * Remove catch handlers in private key retrieval
+   [\#1653](https://github.com/matrix-org/matrix-js-sdk/pull/1653)
+ * Fixed the media fail error on caller's side
+   [\#1651](https://github.com/matrix-org/matrix-js-sdk/pull/1651)
+ * Add function to share megolm keys for historical messages, take 2
+   [\#1640](https://github.com/matrix-org/matrix-js-sdk/pull/1640)
+ * Cache cross-signing private keys if needed on bootstrap
+   [\#1649](https://github.com/matrix-org/matrix-js-sdk/pull/1649)
+
+Changes in [9.10.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0) (2021-03-29)
+==================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.10.0-rc.1...v9.10.0)
+
+ * No changes since rc.1
+
+Changes in [9.10.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0-rc.1) (2021-03-25)
+============================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.9.0...v9.10.0-rc.1)
+
+ * Don't send m.call.hangup if m.call.invite wasn't sent either
+   [\#1647](https://github.com/matrix-org/matrix-js-sdk/pull/1647)
+ * docs: registerGuest()
+   [\#1641](https://github.com/matrix-org/matrix-js-sdk/pull/1641)
+ * Download device keys in chunks of 250
+   [\#1639](https://github.com/matrix-org/matrix-js-sdk/pull/1639)
+ * More VoIP connectivity fixes
+   [\#1646](https://github.com/matrix-org/matrix-js-sdk/pull/1646)
+ * Make selectDesktopCapturerSource param optional
+   [\#1644](https://github.com/matrix-org/matrix-js-sdk/pull/1644)
+ * Expose APIs needed for reworked cross-signing login flow
+   [\#1632](https://github.com/matrix-org/matrix-js-sdk/pull/1632)
+
+Changes in [9.9.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0) (2021-03-15)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.9.0-rc.1...v9.9.0)
+
+ * No changes since rc.1
+
+Changes in [9.9.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0-rc.1) (2021-03-10)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.8.0...v9.9.0-rc.1)
+
+ * Remove detailed Olm session logging
+   [\#1638](https://github.com/matrix-org/matrix-js-sdk/pull/1638)
+ * Add space summary suggested only param
+   [\#1637](https://github.com/matrix-org/matrix-js-sdk/pull/1637)
+ * Check TURN servers periodically, and at start of calls
+   [\#1634](https://github.com/matrix-org/matrix-js-sdk/pull/1634)
+ * Support sending invite reasons
+   [\#1624](https://github.com/matrix-org/matrix-js-sdk/pull/1624)
+ * Bump elliptic from 6.5.3 to 6.5.4
+   [\#1636](https://github.com/matrix-org/matrix-js-sdk/pull/1636)
+ * Add a function to get a room's MXC URI
+   [\#1635](https://github.com/matrix-org/matrix-js-sdk/pull/1635)
+ * Stop streams if the call has ended
+   [\#1633](https://github.com/matrix-org/matrix-js-sdk/pull/1633)
+ * Remove export keyword from global.d.ts
+   [\#1631](https://github.com/matrix-org/matrix-js-sdk/pull/1631)
+ * Fix IndexedDB store creation example
+   [\#1445](https://github.com/matrix-org/matrix-js-sdk/pull/1445)
+ * An attempt to  cleanup how constraints are handled in calls
+   [\#1613](https://github.com/matrix-org/matrix-js-sdk/pull/1613)
+ * Extract display name patterns to constants
+   [\#1628](https://github.com/matrix-org/matrix-js-sdk/pull/1628)
+ * Bump pug-code-gen from 2.0.2 to 2.0.3
+   [\#1630](https://github.com/matrix-org/matrix-js-sdk/pull/1630)
+ * Avoid deadlocks when ensuring Olm sessions for devices
+   [\#1627](https://github.com/matrix-org/matrix-js-sdk/pull/1627)
+ * Filter out edits from other senders in history
+   [\#1626](https://github.com/matrix-org/matrix-js-sdk/pull/1626)
+ * Fix ContentHelpers export
+   [\#1618](https://github.com/matrix-org/matrix-js-sdk/pull/1618)
+ * Add logging to in progress Olm sessions
+   [\#1621](https://github.com/matrix-org/matrix-js-sdk/pull/1621)
+ * Don't ignore ICE candidates received before offer/answer
+   [\#1623](https://github.com/matrix-org/matrix-js-sdk/pull/1623)
+ * Better handling of send failures on VoIP events
+   [\#1622](https://github.com/matrix-org/matrix-js-sdk/pull/1622)
+ * Log when turn creds expire
+   [\#1620](https://github.com/matrix-org/matrix-js-sdk/pull/1620)
+ * Initial Spaces [MSC1772] support
+   [\#1563](https://github.com/matrix-org/matrix-js-sdk/pull/1563)
+ * Add logging to crypto store transactions
+   [\#1617](https://github.com/matrix-org/matrix-js-sdk/pull/1617)
+ * Room helper for getting type and checking if it is a space room
+   [\#1610](https://github.com/matrix-org/matrix-js-sdk/pull/1610)
+
+Changes in [9.8.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0) (2021-03-01)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.8.0-rc.1...v9.8.0)
+
+ * No changes since rc.1
+
+Changes in [9.8.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0-rc.1) (2021-02-24)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.7.0...v9.8.0-rc.1)
+
+ * Optimise prefixed logger
+   [\#1615](https://github.com/matrix-org/matrix-js-sdk/pull/1615)
+ * Add debug logs to encryption prep, take 3
+   [\#1614](https://github.com/matrix-org/matrix-js-sdk/pull/1614)
+ * Add functions for upper & lowercase random strings
+   [\#1612](https://github.com/matrix-org/matrix-js-sdk/pull/1612)
+ * Room helpers for invite permissions and join rules
+   [\#1609](https://github.com/matrix-org/matrix-js-sdk/pull/1609)
+ * Fixed wording in "Adding video track with id" log
+   [\#1606](https://github.com/matrix-org/matrix-js-sdk/pull/1606)
+ * Add more debug logs to encryption prep
+   [\#1605](https://github.com/matrix-org/matrix-js-sdk/pull/1605)
+ * Add option to set ice candidate pool size
+   [\#1604](https://github.com/matrix-org/matrix-js-sdk/pull/1604)
+ * Cancel call if no source was selected
+   [\#1601](https://github.com/matrix-org/matrix-js-sdk/pull/1601)
+
+Changes in [9.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0) (2021-02-16)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.7.0-rc.1...v9.7.0)
+
+ * No changes since rc.1
+
+Changes in [9.7.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0-rc.1) (2021-02-10)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.6.0...v9.7.0-rc.1)
+
+ * Handle undefined peerconn
+   [\#1600](https://github.com/matrix-org/matrix-js-sdk/pull/1600)
+ * ReEmitter: Don't throw if no error handler is attached
+   [\#1599](https://github.com/matrix-org/matrix-js-sdk/pull/1599)
+ * Convert ReEmitter to TS
+   [\#1598](https://github.com/matrix-org/matrix-js-sdk/pull/1598)
+ * Fix typo in main readme
+   [\#1597](https://github.com/matrix-org/matrix-js-sdk/pull/1597)
+ * Remove rogue plus character
+   [\#1596](https://github.com/matrix-org/matrix-js-sdk/pull/1596)
+ * Fix call ID NaN
+   [\#1595](https://github.com/matrix-org/matrix-js-sdk/pull/1595)
+ * Fix Electron type merging
+   [\#1594](https://github.com/matrix-org/matrix-js-sdk/pull/1594)
+ * Fix browser screen share
+   [\#1593](https://github.com/matrix-org/matrix-js-sdk/pull/1593)
+ * Fix desktop Matrix screen sharing
+   [\#1570](https://github.com/matrix-org/matrix-js-sdk/pull/1570)
+ * Guard against confused server retry times
+   [\#1591](https://github.com/matrix-org/matrix-js-sdk/pull/1591)
+ * Decrypt redaction events
+   [\#1589](https://github.com/matrix-org/matrix-js-sdk/pull/1589)
+ * Fix edge cases with peeking where a room is re-peeked
+   [\#1587](https://github.com/matrix-org/matrix-js-sdk/pull/1587)
+
+Changes in [9.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0) (2021-02-03)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.6.0-rc.1...v9.6.0)
+
+ * [Release] Fix edge cases with peeking where a room is re-peeked
+   [\#1588](https://github.com/matrix-org/matrix-js-sdk/pull/1588)
+
+Changes in [9.6.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0-rc.1) (2021-01-29)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.5.1...v9.6.0-rc.1)
+
+ * Add support for getting call stats
+   [\#1584](https://github.com/matrix-org/matrix-js-sdk/pull/1584)
+ * Fix compatibility with v0 calls
+   [\#1583](https://github.com/matrix-org/matrix-js-sdk/pull/1583)
+ * Upgrade deps 2021-01
+   [\#1582](https://github.com/matrix-org/matrix-js-sdk/pull/1582)
+ * Log the call ID when logging that we've received VoIP events
+   [\#1581](https://github.com/matrix-org/matrix-js-sdk/pull/1581)
+ * Fix extra negotiate message in Firefox
+   [\#1579](https://github.com/matrix-org/matrix-js-sdk/pull/1579)
+ * Add debug logs to encryption prep
+   [\#1580](https://github.com/matrix-org/matrix-js-sdk/pull/1580)
+ * Expose getPresence endpoint
+   [\#1578](https://github.com/matrix-org/matrix-js-sdk/pull/1578)
+ * Queue keys for backup even if backup isn't enabled yet
+   [\#1577](https://github.com/matrix-org/matrix-js-sdk/pull/1577)
+ * Stop retrying TURN access when forbidden
+   [\#1576](https://github.com/matrix-org/matrix-js-sdk/pull/1576)
+ * Add DTMF sending support
+   [\#1573](https://github.com/matrix-org/matrix-js-sdk/pull/1573)
+
+Changes in [9.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.1) (2021-01-26)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.5.0...v9.5.1)
+
+ * [Release] Fix compatibility with v0 calls
+   [\#1585](https://github.com/matrix-org/matrix-js-sdk/pull/1585)
+
+Changes in [9.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0) (2021-01-18)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.5.0-rc.1...v9.5.0)
+
+ * No changes since rc.1
+
+Changes in [9.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0-rc.1) (2021-01-13)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.1...v9.5.0-rc.1)
+
+ * Don't log if no WebRTC
+   [\#1574](https://github.com/matrix-org/matrix-js-sdk/pull/1574)
+ * Add _unstable_getSharedRooms
+   [\#1417](https://github.com/matrix-org/matrix-js-sdk/pull/1417)
+ * Bump node-notifier from 8.0.0 to 8.0.1
+   [\#1568](https://github.com/matrix-org/matrix-js-sdk/pull/1568)
+ * Ignore party ID if opponent is v0
+   [\#1567](https://github.com/matrix-org/matrix-js-sdk/pull/1567)
+ * Basic call transfer initiation support
+   [\#1566](https://github.com/matrix-org/matrix-js-sdk/pull/1566)
+ * Room version 6 is now a thing
+   [\#1572](https://github.com/matrix-org/matrix-js-sdk/pull/1572)
+ * Store keys with same index but better trust level
+   [\#1571](https://github.com/matrix-org/matrix-js-sdk/pull/1571)
+ * Use TypeScript source for development, swap to build during release
+   [\#1561](https://github.com/matrix-org/matrix-js-sdk/pull/1561)
+ * Revert "Ignore party ID if opponent is v0"
+   [\#1565](https://github.com/matrix-org/matrix-js-sdk/pull/1565)
+ * Basic call transfer initiation support
+   [\#1558](https://github.com/matrix-org/matrix-js-sdk/pull/1558)
+ * Ignore party ID if opponent is v0
+   [\#1559](https://github.com/matrix-org/matrix-js-sdk/pull/1559)
+ * Honour a call reject event from another of our own devices
+   [\#1562](https://github.com/matrix-org/matrix-js-sdk/pull/1562)
+
+Changes in [9.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.1) (2020-12-21)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.0...v9.4.1)
+
+ * Further script tweaks to get all layers building again
+
+Changes in [9.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0) (2020-12-21)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.0-rc.2...v9.4.0)
+
+ * Revert `postinstall` script change, causes issues for other layers
+
+Changes in [9.4.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.2) (2020-12-16)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.0-rc.1...v9.4.0-rc.2)
+
+ * Remove `postinstall` script which also runs as a dependency
+   [\#1560](https://github.com/matrix-org/matrix-js-sdk/pull/1560)
+
+Changes in [9.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.1) (2020-12-16)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.3.0...v9.4.0-rc.1)
+
+ * Fixes to support line 1 / 2
+   [\#1553](https://github.com/matrix-org/matrix-js-sdk/pull/1553)
+ * Add API for listening to remote hold status, advertise VoIP V1
+   [\#1549](https://github.com/matrix-org/matrix-js-sdk/pull/1549)
+ * A hangup from another client is still valid
+   [\#1555](https://github.com/matrix-org/matrix-js-sdk/pull/1555)
+ * Remove temporary build step for tests
+   [\#1554](https://github.com/matrix-org/matrix-js-sdk/pull/1554)
+ * Move browser build steps to prepublish only
+   [\#1552](https://github.com/matrix-org/matrix-js-sdk/pull/1552)
+ * Extend getSsoLoginUrl for MSC2858
+   [\#1541](https://github.com/matrix-org/matrix-js-sdk/pull/1541)
+
+Changes in [9.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0) (2020-12-07)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.3.0-rc.1...v9.3.0)
+
+* No changes since rc.1
+
+Changes in [9.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0-rc.1) (2020-12-02)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.2.0...v9.3.0-rc.1)
+
+ * Export CallError
+   [\#1551](https://github.com/matrix-org/matrix-js-sdk/pull/1551)
+ * Upgrade dependencies
+   [\#1550](https://github.com/matrix-org/matrix-js-sdk/pull/1550)
+ * Don't log error when environment does not support WebRTC
+   [\#1547](https://github.com/matrix-org/matrix-js-sdk/pull/1547)
+ * Fix dehydration method name
+   [\#1544](https://github.com/matrix-org/matrix-js-sdk/pull/1544)
+
+Changes in [9.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0) (2020-11-23)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.2.0-rc.1...v9.2.0)
+
+ * [Release] Fix dehydration method name
+   [\#1545](https://github.com/matrix-org/matrix-js-sdk/pull/1545)
+
+Changes in [9.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0-rc.1) (2020-11-18)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.1.0...v9.2.0-rc.1)
+
+ * Implement call holding functionality
+   [\#1532](https://github.com/matrix-org/matrix-js-sdk/pull/1532)
+ * Support awaitable one-time dehydration
+   [\#1537](https://github.com/matrix-org/matrix-js-sdk/pull/1537)
+ * Client set profile methods update own user
+   [\#1534](https://github.com/matrix-org/matrix-js-sdk/pull/1534)
+
+Changes in [9.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0) (2020-11-09)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.1.0-rc.1...v9.1.0)
+
+* No changes since rc.1
+
+Changes in [9.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0-rc.1) (2020-11-04)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.0.1...v9.1.0-rc.1)
+
+ * Fix spelling error in the server ACL event type
+   [\#1535](https://github.com/matrix-org/matrix-js-sdk/pull/1535)
+ * await idb operations from crypto store for dehydration
+   [\#1533](https://github.com/matrix-org/matrix-js-sdk/pull/1533)
+ * Fix stuck never-sending messages
+   [\#1531](https://github.com/matrix-org/matrix-js-sdk/pull/1531)
+ * Await key cache check to avoid prompts
+   [\#1529](https://github.com/matrix-org/matrix-js-sdk/pull/1529)
+ * Improve ICE candidate batching
+   [\#1524](https://github.com/matrix-org/matrix-js-sdk/pull/1524)
+ * Convert logger to typescript
+   [\#1527](https://github.com/matrix-org/matrix-js-sdk/pull/1527)
+ * Fix logger typo
+   [\#1525](https://github.com/matrix-org/matrix-js-sdk/pull/1525)
+ * bind online listener to window instead of document
+   [\#1523](https://github.com/matrix-org/matrix-js-sdk/pull/1523)
+ * Support m.call.select_answer
+   [\#1522](https://github.com/matrix-org/matrix-js-sdk/pull/1522)
+
+Changes in [9.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.1) (2020-10-28)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.0.0...v9.0.1)
+
+ * [Release] Await key cache check to avoid prompts
+   [\#1530](https://github.com/matrix-org/matrix-js-sdk/pull/1530)
+
+Changes in [9.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0) (2020-10-26)
+================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.0.0-rc.1...v9.0.0)
+
+ * Fix logger typo
+   [\#1528](https://github.com/matrix-org/matrix-js-sdk/pull/1528)
+
+Changes in [9.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0-rc.1) (2020-10-21)
+==========================================================================================================
+[Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.5.0...v9.0.0-rc.1)
+
+BREAKING CHANGES
+---
+
+ * `hasPendingEvent` now returns false instead of throwing when pending ordering mode is not `detached`
+
+All changes
+---
+
+ * Don't cache failures when fetching /versions
+   [\#1521](https://github.com/matrix-org/matrix-js-sdk/pull/1521)
+ * Install deps first as part of release
+   [\#1518](https://github.com/matrix-org/matrix-js-sdk/pull/1518)
+ * [Breaking] Change hasPendingEvent to return false if pending ordering
+   !detached
+   [\#1517](https://github.com/matrix-org/matrix-js-sdk/pull/1517)
+ * Skip editor prompts for merges
+   [\#1519](https://github.com/matrix-org/matrix-js-sdk/pull/1519)
+ * Convert call test to TypeScript
+   [\#1516](https://github.com/matrix-org/matrix-js-sdk/pull/1516)
+ * Support party_id
+   [\#1512](https://github.com/matrix-org/matrix-js-sdk/pull/1512)
+ * Support m.call.reject
+   [\#1510](https://github.com/matrix-org/matrix-js-sdk/pull/1510)
+ * Remove specbuild from .gitignore
+   [\#1515](https://github.com/matrix-org/matrix-js-sdk/pull/1515)
+ * Log the error when we failed to send candidates
+   [\#1514](https://github.com/matrix-org/matrix-js-sdk/pull/1514)
+ * Fixes for call state machine
+   [\#1503](https://github.com/matrix-org/matrix-js-sdk/pull/1503)
+ * Fix call event handler listener removing
+   [\#1506](https://github.com/matrix-org/matrix-js-sdk/pull/1506)
+ * Set the type of the call based on the tracks
+   [\#1501](https://github.com/matrix-org/matrix-js-sdk/pull/1501)
+ * Use new local timestamp for calls
+   [\#1499](https://github.com/matrix-org/matrix-js-sdk/pull/1499)
+ * Adjust types and APIs to match React SDK
+   [\#1502](https://github.com/matrix-org/matrix-js-sdk/pull/1502)
+ * Make an accurate version of 'age' for events
+   [\#1495](https://github.com/matrix-org/matrix-js-sdk/pull/1495)
+ * Make 'options' parameter optional
+   [\#1498](https://github.com/matrix-org/matrix-js-sdk/pull/1498)
+ * Create a giant event type enum
+   [\#1497](https://github.com/matrix-org/matrix-js-sdk/pull/1497)
+ * Convert call.js to Typescript & update WebRTC APIs (re-apply)
+   [\#1494](https://github.com/matrix-org/matrix-js-sdk/pull/1494)
+
 Changes in [8.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.5.0) (2020-10-12)
 ================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.5.0-rc.1...v8.5.0)
@@ -307,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.

@@ -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);
    };
@@ -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>
@@ -1,23 +1,25 @@
 {
  "name": "matrix-js-sdk",
-  "version": "8.5.0",
+  "version": "11.2.0",
  "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": "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 --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:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
    "gendoc": "jsdoc -c jsdoc.json -P package.json",
    "lint": "yarn lint:types && yarn lint:js",
-    "lint:js": "eslint --max-warnings 76 src spec",
+    "lint:js": "eslint --max-warnings 72 src spec",
    "lint:types": "tsc --noEmit",
-    "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",
@@ -27,10 +29,11 @@
    "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": [
@@ -46,51 +49,65 @@
    "release.sh"
  ],
  "dependencies": {
-    "@babel/runtime": "^7.11.2",
+    "@babel/runtime": "^7.12.5",
    "another-json": "^0.2.0",
    "browser-request": "^0.3.3",
    "bs58": "^4.0.1",
    "content-type": "^1.0.4",
-    "loglevel": "^1.7.0",
-    "qs": "^6.9.4",
+    "loglevel": "^1.7.1",
+    "qs": "^6.9.6",
    "request": "^2.88.2",
    "unhomoglyph": "^1.0.6"
  },
  "devDependencies": {
-    "@babel/cli": "^7.11.6",
-    "@babel/core": "^7.11.6",
-    "@babel/plugin-proposal-class-properties": "^7.10.4",
-    "@babel/plugin-proposal-numeric-separator": "^7.10.4",
-    "@babel/plugin-proposal-object-rest-spread": "^7.11.0",
+    "@babel/cli": "^7.12.10",
+    "@babel/core": "^7.12.10",
+    "@babel/eslint-parser": "^7.12.10",
+    "@babel/eslint-plugin": "^7.12.10",
+    "@babel/plugin-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.11.5",
-    "@babel/preset-env": "^7.11.5",
-    "@babel/preset-typescript": "^7.10.4",
-    "@babel/register": "^7.11.5",
+    "@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/jest": "^26.0.20",
    "@types/node": "12",
    "@types/request": "^2.48.5",
-    "babel-eslint": "^10.1.0",
-    "babel-jest": "^24.9.0",
+    "@typescript-eslint/eslint-plugin": "^4.17.0",
+    "@typescript-eslint/parser": "^4.17.0",
+    "babel-jest": "^26.6.3",
    "babelify": "^10.0.0",
    "better-docs": "^2.3.2",
-    "browserify": "^16.5.2",
+    "browserify": "^17.0.0",
    "docdash": "^1.2.0",
-    "eslint": "7.9.0",
-    "eslint-config-matrix-org": "^0.1.2",
-    "eslint-plugin-babel": "^5.3.1",
+    "eslint": "7.18.0",
+    "eslint-config-google": "^0.14.0",
+    "eslint-plugin-matrix-org": "github:matrix-org/eslint-plugin-matrix-org#main",
    "exorcist": "^1.0.1",
    "fake-indexeddb": "^3.1.2",
-    "jest": "^24.9.0",
-    "jest-localstorage-mock": "^2.4.3",
+    "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.2.1.tgz",
    "rimraf": "^3.0.2",
-    "terser": "^4.8.0",
-    "tsify": "^4.0.2",
-    "typescript": "^3.9.7"
+    "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"
 }
@@ -94,6 +94,14 @@ if [ $# -ne 1 ]; then
    exit 1
 fi

+# We use Git branch / commit dependencies for some packages, and Yarn seems
+# to have a hard time getting that right. See also
+# https://github.com/yarnpkg/yarn/issues/4734. As a workaround, we clean the
+# global cache here to ensure we get the right thing.
+yarn cache clean
+# Ensure all dependencies are updated
+yarn install --ignore-scripts
+
 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)
@@ -170,6 +178,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
@@ -204,11 +225,6 @@ 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
    # We haven't tagged yet, so tell the dist script what version
    # it's building
@@ -340,7 +356,7 @@ fi
 echo "updating master branch"
 git checkout master
 git pull
-git merge "$rel_branch"
+git merge "$rel_branch" --no-edit

 # push master to github
 git push origin master
@@ -349,6 +365,31 @@ git push origin master
 if [ $(git branch -lr | grep origin/develop -c) -ge 1 ]; then
    git checkout develop
    git pull
-    git merge master
+    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
@@ -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
@@ -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;
+};
@@ -17,10 +17,10 @@ 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 { 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 { LocalStorageCryptoStore } from "../../src/crypto/store/localStorage-crypto-store";
 import * as utils from "../test-utils";

 const USER_ID = "@user:test.server";
@@ -58,7 +58,7 @@ describe("Browserify Test", function() {
    }

    beforeEach(async () => {
-        ({client, httpBackend} = await createTestClient());
+        ({ client, httpBackend } = await createTestClient());
        await client.startClient();
    });

@@ -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/element-web/issues/3126
-           aliceTestClient.expectKeyQuery({device_keys: {'@alice:localhost': {}}});
+           aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
           return aliceTestClient.start().then(() => {
               aliceTestClient.httpBackend.when('GET', '/sync').respond(
                   200, getSyncResponse(['@bob:xyz', '@chris:abc']));
@@ -160,7 +158,7 @@ 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'),
@@ -199,7 +197,7 @@ 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) => {
@@ -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) => {
@@ -323,7 +321,6 @@ describe("DeviceList management:", function() {
                },
            );

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

@@ -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";
@@ -76,7 +75,7 @@ function expectAliQueryKeys() {
        );
        const result = {};
        result[bobUserId] = bobKeys;
-        return {device_keys: result};
+        return { device_keys: result };
    });
    return aliTestClient.httpBackend.flush("/keys/query", 1);
 }
@@ -104,7 +103,7 @@ function expectBobQueryKeys() {
        );
        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();
@@ -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))
@@ -1,5 +1,5 @@
 import * as utils from "../test-utils";
-import {TestClient} from "../TestClient";
+import { TestClient } from "../TestClient";

 describe("MatrixClient events", function() {
    let client;
@@ -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

@@ -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;
@@ -346,10 +345,10 @@ describe("MatrixClient", function() {
            */

            httpBackend.when("POST", "/keys/query").check(function(req) {
-                expect(req.data).toEqual({device_keys: {
+                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);
@@ -1,9 +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 {MatrixError} from "../../src/http-api";
+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";
@@ -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;
@@ -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;
@@ -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) => {
@@ -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': {},
        };
@@ -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);
@@ -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,60 @@ 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();
+            });
+        });
+    });
 });
@@ -15,12 +15,12 @@ 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");
@@ -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
@@ -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,
 ) {
@@ -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();
+    });
+});
@@ -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;
@@ -1,4 +1,4 @@
-import {getHttpUriForMxc} from "../../src/content-repo";
+import { getHttpUriForMxc } from "../../src/content-repo";

 describe("ContentRepo", function() {
    const baseUrl = "https://my.home.server";
@@ -1,16 +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 {DeviceInfo} from "../../src/crypto/deviceinfo";
+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;

@@ -46,7 +46,7 @@ describe("Crypto", function() {

            // unknown sender (e.g. deleted device), forwarded megolm key (untrusted)
            event.getSenderKey = () => 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI';
-            event.getWireContent = () => {return {algorithm: olmlib.MEGOLM_ALGORITHM};};
+            event.getWireContent = () => {return { algorithm: olmlib.MEGOLM_ALGORITHM };};
            event.getForwardingCurve25519KeyChain = () => ["not empty"];
            event.isKeySourceUntrusted = () => false;
            event.getClaimedEd25519Key =
@@ -22,11 +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';
+import { OlmDevice } from "../../../src/crypto/OlmDevice";
+import { logger } from '../../../src/logger';

 const userId = "@alice:example.com";

@@ -66,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,
        });
@@ -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,7 +99,7 @@ describe('DeviceList', function() {
        }
    });

-    function createTestDeviceList() {
+    function createTestDeviceList(keyDownloadChunkSize = 250) {
        const baseApis = {
            downloadKeysForUsers: downloadSpy,
            getUserId: () => '@test1:sw1v.org',
@@ -78,7 +108,7 @@ describe('DeviceList', function() {
        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;
    }
@@ -150,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']);
+        });
+    });
 });
@@ -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) => {
@@ -313,7 +312,7 @@ describe("MegolmDecryption", function() {
            });
            const mockRoom = {
                getEncryptionTargetMembers: jest.fn().mockReturnValue(
-                    [{userId: "@alice:home.server"}],
+                    [{ userId: "@alice:home.server" }],
                ),
                getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
            };
@@ -373,7 +372,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);
@@ -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);
+        });
    });
 });
@@ -16,18 +16,18 @@ 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 {resetCrossSigningKeys} from "./crypto-utils";
+import { OlmDevice } from "../../../src/crypto/OlmDevice";
+import { Crypto } from "../../../src/crypto";
+import { resetCrossSigningKeys } from "./crypto-utils";

 const Olm = global.Olm;

@@ -18,11 +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';
+import { logger } from '../../../src/logger';

 async function makeTestClient(userInfo, options, keys) {
    if (!keys) keys = {};
@@ -60,7 +60,7 @@ 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(
@@ -80,7 +80,7 @@ describe("Cross Signing", function() {

    it("should abort bootstrap if device signing auth fails", async function() {
        const alice = await makeTestClient(
-            {userId: "@alice:example.com", deviceId: "Osborne2"},
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
        );
        alice.uploadDeviceSigningKeys = async (auth, keys) => {
            const errorResponse = {
@@ -131,7 +131,7 @@ describe("Cross Signing", function() {

    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 () => {};
@@ -175,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
@@ -193,7 +193,9 @@ 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,
+                });
            });
        });

@@ -326,7 +328,7 @@ 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 () => {};
@@ -411,7 +413,7 @@ 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,
        );
@@ -573,7 +575,7 @@ 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 () => {};
@@ -642,7 +644,7 @@ 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 () => {};
@@ -780,7 +782,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) => {
@@ -792,7 +794,7 @@ describe("Cross Signing", function() {
            },
        );
        const bob = await makeTestClient(
-            {userId: "@bob:example.com", deviceId: "Dynabook"},
+            { userId: "@bob:example.com", deviceId: "Dynabook" },
        );

        bob.uploadDeviceSigningKeys = async () => {};
@@ -1,5 +1,4 @@
-import {IndexedDBCryptoStore} from '../../../src/crypto/store/indexeddb-crypto-store';
-
+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.
@@ -17,7 +17,7 @@ limitations under the License.
 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';

@@ -16,13 +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 {encryptAES} from "../../../src/crypto/aes";
-import {resetCrossSigningKeys, createSecretStorageKey} from "./crypto-utils";
-import {logger} from '../../../src/logger';
+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";

@@ -91,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,
@@ -141,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 {
@@ -155,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 {
@@ -175,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],
@@ -194,7 +194,7 @@ describe("Secrets", function() {
        };
        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
@@ -208,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 {
@@ -221,13 +221,13 @@ 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";
                    },
                },
@@ -419,12 +419,12 @@ describe("Secrets", function() {
                key_id: SSSSKey,
            };
            const alice = await makeTestClient(
-                {userId: "@alice:example.com", deviceId: "Osborne2"},
+                { userId: "@alice:example.com", deviceId: "Osborne2" },
                {
                    cryptoCallbacks: {
                        getCrossSigningKey: t => crossSigningKeys[t],
                        saveCrossSigningKeys: k => crossSigningKeys = k,
-                        getSecretStorageKey: ({keys}, name) => {
+                        getSecretStorageKey: ({ keys }, name) => {
                            for (const keyId of Object.keys(keys)) {
                                if (secretStorageKeys[keyId]) {
                                    return [keyId, secretStorageKeys[keyId]];
@@ -458,7 +458,7 @@ describe("Secrets", function() {
                    type: "m.cross_signing.master",
                    content: {
                        encrypted: {
-                            key_id: {ciphertext: "bla", mac: "bla", iv: "bla"},
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
                        },
                    },
                }),
@@ -466,7 +466,7 @@ describe("Secrets", function() {
                    type: "m.cross_signing.self_signing",
                    content: {
                        encrypted: {
-                            key_id: {ciphertext: "bla", mac: "bla", iv: "bla"},
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
                        },
                    },
                }),
@@ -474,7 +474,7 @@ describe("Secrets", function() {
                    type: "m.cross_signing.user_signing",
                    content: {
                        encrypted: {
-                            key_id: {ciphertext: "bla", mac: "bla", iv: "bla"},
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
                        },
                    },
                }),
@@ -525,7 +525,7 @@ describe("Secrets", function() {
            await alice.bootstrapSecretStorage();

            expect(alice.getAccountData("m.secret_storage.default_key").getContent())
-                .toEqual({key: "key_id"});
+                .toEqual({ key: "key_id" });
            const keyInfo = alice.getAccountData("m.secret_storage.key.key_id")
                .getContent();
            expect(keyInfo.algorithm)
@@ -550,12 +550,12 @@ describe("Secrets", function() {
                key_id: SSSSKey,
            };
            const alice = await makeTestClient(
-                {userId: "@alice:example.com", deviceId: "Osborne2"},
+                { userId: "@alice:example.com", deviceId: "Osborne2" },
                {
                    cryptoCallbacks: {
                        getCrossSigningKey: t => crossSigningKeys[t],
                        saveCrossSigningKeys: k => crossSigningKeys = k,
-                        getSecretStorageKey: ({keys}, name) => {
+                        getSecretStorageKey: ({ keys }, name) => {
                            for (const keyId of Object.keys(keys)) {
                                if (secretStorageKeys[keyId]) {
                                    return [keyId, secretStorageKeys[keyId]];
@@ -587,7 +587,7 @@ describe("Secrets", function() {
                    type: "m.cross_signing.master",
                    content: {
                        encrypted: {
-                            key_id: {ciphertext: "bla", mac: "bla", iv: "bla"},
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
                        },
                    },
                }),
@@ -595,7 +595,7 @@ describe("Secrets", function() {
                    type: "m.cross_signing.self_signing",
                    content: {
                        encrypted: {
-                            key_id: {ciphertext: "bla", mac: "bla", iv: "bla"},
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
                        },
                    },
                }),
@@ -603,7 +603,7 @@ describe("Secrets", function() {
                    type: "m.cross_signing.user_signing",
                    content: {
                        encrypted: {
-                            key_id: {ciphertext: "bla", mac: "bla", iv: "bla"},
+                            key_id: { ciphertext: "bla", mac: "bla", iv: "bla" },
                        },
                    },
                }),
@@ -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";
@@ -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;

@@ -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,8 +42,8 @@ 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],
@@ -15,14 +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 {resetCrossSigningKeys} from "../crypto-utils";
+import { logger } from "../../../../src/logger";
+import { resetCrossSigningKeys } from "../crypto-utils";

 const Olm = global.Olm;

@@ -79,8 +79,8 @@ 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],
@@ -336,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],
@@ -390,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],
@@ -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();

@@ -15,10 +15,10 @@ 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';
+import { logger } from '../../../../src/logger';

 export async function makeTestClients(userInfos, options) {
    const clients = [];
@@ -30,7 +30,7 @@ export async function makeTestClients(userInfos, options) {
                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,
                        });
@@ -49,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,
@@ -61,13 +61,13 @@ 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
+                if (tc.client === this) { // eslint-disable-line @babel/no-invalid-this
                    logger.log("sending remote echo!!");
                    tc.client.emit("Room.timeline", remoteEcho);
                } else {
@@ -76,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) {
@@ -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 });
        }
    }

@@ -226,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();
@@ -1,6 +1,6 @@
 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");
@@ -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;
        };
@@ -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 = [
@@ -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", () => {
@@ -1,5 +1,5 @@
-import {FilterComponent} from "../../src/filter-component";
-import {mkEvent} from '../test-utils';
+import { FilterComponent } from "../../src/filter-component";
+import { mkEvent } from '../test-utils';

 describe("Filter Component", function() {
    describe("types", function() {
@@ -1,4 +1,4 @@
-import {Filter} from "../../src/filter";
+import { Filter } from "../../src/filter";

 describe("Filter", function() {
    const filterId = "f1lt3ring15g00d4ursoul";
@@ -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({
@@ -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");
@@ -1,4 +1,4 @@
-import {TestClient} from '../TestClient';
+import { TestClient } from '../TestClient';

 describe('Login request', function() {
    let client;
@@ -1,6 +1,6 @@
-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";

 jest.useFakeTimers();

@@ -178,7 +178,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 +521,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);
+        });
+    });
 });
@@ -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";
@@ -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);
@@ -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 { Relations } from "../../src/models/relations";
+
+describe("Relations", function() {
+    it("should deduplicate annotations", function() {
+        const relations = new Relations("m.annotation", "m.reaction");
+
+        // 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 = {
+            getPendingEvent() { return null; },
+            getUnfilteredTimelineSet() { return 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;
+        }
+    });
+});
@@ -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";
@@ -1,6 +1,6 @@
 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";
+import { RoomMember } from "../../src/models/room-member";

 describe("RoomState", function() {
    const roomId = "!foo:bar";
@@ -471,13 +471,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 +490,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 +509,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 +525,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 +545,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 +561,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);
        });
@@ -1,8 +1,9 @@
 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 { 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 { TestClient } from "../TestClient";

 describe("Room", function() {
    const roomId = "!foo:bar";
@@ -190,7 +191,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;
@@ -374,7 +375,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 = [
@@ -456,7 +457,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 = [
@@ -712,7 +713,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],
                });
@@ -723,7 +724,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,
@@ -736,8 +737,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],
                });
@@ -747,7 +748,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],
@@ -840,7 +841,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;
@@ -915,8 +916,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");
@@ -926,7 +927,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);
@@ -1176,7 +1177,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({
@@ -1226,7 +1230,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({
@@ -1260,7 +1267,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,7 +1320,7 @@ describe("Room", function() {
                        if (this.serverResponse instanceof Error) {
                            return Promise.reject(this.serverResponse);
                        } else {
-                            return Promise.resolve({chunk: this.serverResponse});
+                            return Promise.resolve({ chunk: this.serverResponse });
                        }
                    },
                },
@@ -1344,7 +1350,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");
@@ -1359,7 +1365,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();

@@ -1369,7 +1375,7 @@ 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();
@@ -1397,17 +1403,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" });
        });
    });

@@ -1415,7 +1421,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",
@@ -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);
@@ -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);
@@ -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]),
+            );
+        });
    });
 });

@@ -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;
@@ -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() {
@@ -26,40 +26,6 @@ describe("utils", function() {
        });
    });

-    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() {
@@ -103,20 +69,6 @@ describe("utils", function() {
        });
    });

-    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() {
@@ -188,19 +140,19 @@ describe("utils", function() {

        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({ 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.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({ 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));
@@ -223,7 +175,6 @@ describe("utils", function() {
        });
    });

-
    describe("extend", function() {
        const SOURCE = { "prop2": 1, "string2": "x", "newprop": "new" };

@@ -282,4 +233,30 @@ describe("utils", function() {
            expect(target.nonenumerableProp).toBe(undefined);
        });
    });
+
+    describe("chunkPromises", function() {
+        it("should execute promises in chunks", async function() {
+            let promiseCount = 0;
+
+            function fn1() {
+                return new Promise(async function(resolve, reject) {
+                    await utils.sleep(1);
+                    expect(promiseCount).toEqual(0);
+                    ++promiseCount;
+                    resolve();
+                });
+            }
+
+            function fn2() {
+                return new Promise(function(resolve, reject) {
+                    expect(promiseCount).toEqual(1);
+                    ++promiseCount;
+                    resolve();
+                });
+            }
+
+            await utils.chunkPromises([fn1, fn2], 1);
+            expect(promiseCount).toEqual(2);
+        });
+    });
 });
@@ -0,0 +1,301 @@
+/*
+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';
+
+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 []; }
+}
+
+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: () => {
+                    return {
+                        getTracks: () => [],
+                        getAudioTracks: () => [],
+                        getVideoTracks: () => [],
+                    };
+                },
+            },
+        };
+
+        global.window = {
+            // @ts-ignore Mock
+            RTCPeerConnection: MockRTCPeerConnection,
+            // @ts-ignore Mock
+            RTCSessionDescription: {},
+            // @ts-ignore Mock
+            RTCIceCandidate: {},
+            getUserMedia: {},
+        };
+        // @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.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);
+    });
+});
@@ -0,0 +1,102 @@
+/*
+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.
+*/
+
+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",
+    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",
+
+    // 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 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",
+}
@@ -15,7 +15,7 @@ limitations under the License.
 */

 // this is needed to tell TS about global.Olm
-import * as Olm from "olm"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as Olm from "@matrix-org/olm"; // eslint-disable-line @typescript-eslint/no-unused-vars

 export {};

@@ -25,4 +25,63 @@ declare global {
            localStorage: Storage;
        }
    }
+
+    interface Window {
+        electron?: Electron;
+    }
+
+    interface Electron {
+        getDesktopCapturerSources(options: GetSourcesOptions): Promise<Array<DesktopCapturerSource>>;
+    }
+
+    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 DesktopCapturerSource {
+        id: string;
+        name: string;
+        thumbnailURL: string;
+    }
+
+    interface GetSourcesOptions {
+        types: Array<string>;
+        thumbnailSize?: {
+            height: number;
+            width: number;
+        };
+        fetchWindowIcons?: boolean;
+    }
+
+    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;
+    }
 }
@@ -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);
-        }
-    }
-}
@@ -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);
+        }
+    }
+}
@@ -17,8 +17,8 @@ limitations under the License.

 /** @module auto-discovery */

-import {logger} from './logger';
-import {URL as NodeURL} from "url";
+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
@@ -511,12 +511,12 @@ export class AutoDiscovery {
                            action = "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: "SUCCESS" });
                    } catch (e) {
                        let reason = AutoDiscovery.ERROR_INVALID;
                        if (e.name === "SyntaxError") {
@@ -24,11 +24,11 @@ limitations under the License.
 * @module base-apis
 */

-import {SERVICE_TYPES} from './service-types';
-import {logger} from './logger';
-import {PushProcessor} from "./pushprocessor";
+import { SERVICE_TYPES } from './service-types';
+import { logger } from './logger';
+import { PushProcessor } from "./pushprocessor";
 import * as utils from "./utils";
-import {MatrixHttpApi, PREFIX_IDENTITY_V2, PREFIX_R0, PREFIX_UNSTABLE} from "./http-api";
+import { MatrixHttpApi, PREFIX_IDENTITY_V2, PREFIX_R0, PREFIX_UNSTABLE } from "./http-api";

 function termsUrlForService(serviceType, baseUrl) {
    switch (serviceType) {
@@ -158,7 +158,6 @@ MatrixBaseApis.prototype.makeTxnId = function() {
    return "m" + new Date().getTime() + "." + (this._txnCtr++);
 };

-
 // Registration/Login operations
 // =============================

@@ -197,7 +196,7 @@ MatrixBaseApis.prototype.register = function(
 ) {
    // backwards compat
    if (bindThreepids === true) {
-        bindThreepids = {email: true};
+        bindThreepids = { email: true };
    } else if (bindThreepids === null || bindThreepids === undefined) {
        bindThreepids = {};
    }
@@ -246,10 +245,25 @@ MatrixBaseApis.prototype.register = function(

 /**
 * Register a guest account.
+ * This method returns the auth info needed to create a new authenticated client,
+ * Remember to call `setGuest(true)` on the (guest-)authenticated client, e.g:
+ * ```javascript
+ * const tmpClient = await sdk.createClient(MATRIX_INSTANCE);
+ * const { user_id, device_id, access_token } = tmpClient.registerGuest();
+ * const client = createClient({
+ *   baseUrl: MATRIX_INSTANCE,
+ *   accessToken: access_token,
+ *   userId: user_id,
+ *   deviceId: device_id,
+ * })
+ * client.setGuest(true);
+ * ```
+ *
 * @param {Object=} opts Registration options
 * @param {Object} opts.body JSON HTTP body to provide.
 * @param {module:client.callback} callback Optional.
- * @return {Promise} Resolves: TODO
+ * @return {Promise} Resolves: JSON object that contains:
+ *                   { user_id, device_id, access_token, home_server }
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.registerGuest = function(opts, callback) {
@@ -356,15 +370,20 @@ MatrixBaseApis.prototype.getCasLoginUrl = function(redirectUrl) {
 *     authenticates with the SSO.
 * @param {string} loginType The type of SSO login we are doing (sso or cas).
 *     Defaults to 'sso'.
+ * @param {string} idpId The ID of the Identity Provider being targeted, optional.
 * @return {string} The HS URL to hit to begin the SSO login process.
 */
-MatrixBaseApis.prototype.getSsoLoginUrl = function(redirectUrl, loginType) {
+MatrixBaseApis.prototype.getSsoLoginUrl = function(redirectUrl, loginType, idpId) {
    if (loginType === undefined) {
        loginType = "sso";
    }
-    return this._http.getUrl("/login/"+loginType+"/redirect", {
-        "redirectUrl": redirectUrl,
-    }, PREFIX_R0);
+
+    let url = "/login/" + loginType + "/redirect";
+    if (idpId) {
+        url += "/" + idpId;
+    }
+
+    return this._http.getUrl(url, { redirectUrl }, PREFIX_R0);
 };

 /**
@@ -379,7 +398,6 @@ MatrixBaseApis.prototype.loginWithToken = function(token, callback) {
    }, callback);
 };

-
 /**
 * Logs out the current session.
 * Obviously, further calls that require authorisation should fail after this
@@ -525,7 +543,7 @@ MatrixBaseApis.prototype.fetchRelations =
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.roomState = function(roomId, callback) {
-    const path = utils.encodeUri("/rooms/$roomId/state", {$roomId: roomId});
+    const path = utils.encodeUri("/rooms/$roomId/state", { $roomId: roomId });
    return this._http.authedRequest(callback, "GET", path);
 };

@@ -573,7 +591,7 @@ function(roomId, includeMembership, excludeMembership, atEventId, callback) {
    const queryString = utils.encodeParams(queryParams);

    const path = utils.encodeUri("/rooms/$roomId/members?" + queryString,
-        {$roomId: roomId});
+        { $roomId: roomId });
    return this._http.authedRequest(callback, "GET", path);
 };

@@ -585,20 +603,19 @@ function(roomId, includeMembership, excludeMembership, atEventId, callback) {
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.upgradeRoom = function(roomId, newVersion) {
-    const path = utils.encodeUri("/rooms/$roomId/upgrade", {$roomId: roomId});
+    const path = utils.encodeUri("/rooms/$roomId/upgrade", { $roomId: roomId });
    return this._http.authedRequest(
-        undefined, "POST", path, undefined, {new_version: newVersion},
+        undefined, "POST", path, undefined, { new_version: newVersion },
    );
 };

-
 /**
 * @param {string} groupId
 * @return {Promise} Resolves: Group summary object
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.getGroupSummary = function(groupId) {
-    const path = utils.encodeUri("/groups/$groupId/summary", {$groupId: groupId});
+    const path = utils.encodeUri("/groups/$groupId/summary", { $groupId: groupId });
    return this._http.authedRequest(undefined, "GET", path);
 };

@@ -608,7 +625,7 @@ MatrixBaseApis.prototype.getGroupSummary = function(groupId) {
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.getGroupProfile = function(groupId) {
-    const path = utils.encodeUri("/groups/$groupId/profile", {$groupId: groupId});
+    const path = utils.encodeUri("/groups/$groupId/profile", { $groupId: groupId });
    return this._http.authedRequest(undefined, "GET", path);
 };

@@ -623,7 +640,7 @@ MatrixBaseApis.prototype.getGroupProfile = function(groupId) {
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.setGroupProfile = function(groupId, profile) {
-    const path = utils.encodeUri("/groups/$groupId/profile", {$groupId: groupId});
+    const path = utils.encodeUri("/groups/$groupId/profile", { $groupId: groupId });
    return this._http.authedRequest(
        undefined, "POST", path, undefined, profile,
    );
@@ -641,7 +658,7 @@ MatrixBaseApis.prototype.setGroupProfile = function(groupId, profile) {
 MatrixBaseApis.prototype.setGroupJoinPolicy = function(groupId, policy) {
    const path = utils.encodeUri(
        "/groups/$groupId/settings/m.join_policy",
-        {$groupId: groupId},
+        { $groupId: groupId },
    );
    return this._http.authedRequest(
        undefined, "PUT", path, undefined, {
@@ -656,7 +673,7 @@ MatrixBaseApis.prototype.setGroupJoinPolicy = function(groupId, policy) {
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.getGroupUsers = function(groupId) {
-    const path = utils.encodeUri("/groups/$groupId/users", {$groupId: groupId});
+    const path = utils.encodeUri("/groups/$groupId/users", { $groupId: groupId });
    return this._http.authedRequest(undefined, "GET", path);
 };

@@ -666,7 +683,7 @@ MatrixBaseApis.prototype.getGroupUsers = function(groupId) {
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.getGroupInvitedUsers = function(groupId) {
-    const path = utils.encodeUri("/groups/$groupId/invited_users", {$groupId: groupId});
+    const path = utils.encodeUri("/groups/$groupId/invited_users", { $groupId: groupId });
    return this._http.authedRequest(undefined, "GET", path);
 };

@@ -676,7 +693,7 @@ MatrixBaseApis.prototype.getGroupInvitedUsers = function(groupId) {
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.getGroupRooms = function(groupId) {
-    const path = utils.encodeUri("/groups/$groupId/rooms", {$groupId: groupId});
+    const path = utils.encodeUri("/groups/$groupId/rooms", { $groupId: groupId });
    return this._http.authedRequest(undefined, "GET", path);
 };

@@ -689,7 +706,7 @@ MatrixBaseApis.prototype.getGroupRooms = function(groupId) {
 MatrixBaseApis.prototype.inviteUserToGroup = function(groupId, userId) {
    const path = utils.encodeUri(
        "/groups/$groupId/admin/users/invite/$userId",
-        {$groupId: groupId, $userId: userId},
+        { $groupId: groupId, $userId: userId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined, {});
 };
@@ -703,7 +720,7 @@ MatrixBaseApis.prototype.inviteUserToGroup = function(groupId, userId) {
 MatrixBaseApis.prototype.removeUserFromGroup = function(groupId, userId) {
    const path = utils.encodeUri(
        "/groups/$groupId/admin/users/remove/$userId",
-        {$groupId: groupId, $userId: userId},
+        { $groupId: groupId, $userId: userId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined, {});
 };
@@ -720,7 +737,7 @@ MatrixBaseApis.prototype.addUserToGroupSummary = function(groupId, userId, roleI
        roleId ?
            "/groups/$groupId/summary/$roleId/users/$userId" :
            "/groups/$groupId/summary/users/$userId",
-        {$groupId: groupId, $roleId: roleId, $userId: userId},
+        { $groupId: groupId, $roleId: roleId, $userId: userId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined, {});
 };
@@ -734,7 +751,7 @@ MatrixBaseApis.prototype.addUserToGroupSummary = function(groupId, userId, roleI
 MatrixBaseApis.prototype.removeUserFromGroupSummary = function(groupId, userId) {
    const path = utils.encodeUri(
        "/groups/$groupId/summary/users/$userId",
-        {$groupId: groupId, $userId: userId},
+        { $groupId: groupId, $userId: userId },
    );
    return this._http.authedRequest(undefined, "DELETE", path, undefined, {});
 };
@@ -751,7 +768,7 @@ MatrixBaseApis.prototype.addRoomToGroupSummary = function(groupId, roomId, categ
        categoryId ?
            "/groups/$groupId/summary/$categoryId/rooms/$roomId" :
            "/groups/$groupId/summary/rooms/$roomId",
-        {$groupId: groupId, $categoryId: categoryId, $roomId: roomId},
+        { $groupId: groupId, $categoryId: categoryId, $roomId: roomId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined, {});
 };
@@ -765,7 +782,7 @@ MatrixBaseApis.prototype.addRoomToGroupSummary = function(groupId, roomId, categ
 MatrixBaseApis.prototype.removeRoomFromGroupSummary = function(groupId, roomId) {
    const path = utils.encodeUri(
        "/groups/$groupId/summary/rooms/$roomId",
-        {$groupId: groupId, $roomId: roomId},
+        { $groupId: groupId, $roomId: roomId },
    );
    return this._http.authedRequest(undefined, "DELETE", path, undefined, {});
 };
@@ -783,7 +800,7 @@ MatrixBaseApis.prototype.addRoomToGroup = function(groupId, roomId, isPublic) {
    }
    const path = utils.encodeUri(
        "/groups/$groupId/admin/rooms/$roomId",
-        {$groupId: groupId, $roomId: roomId},
+        { $groupId: groupId, $roomId: roomId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined,
        { "m.visibility": { type: isPublic ? "public" : "private" } },
@@ -805,7 +822,7 @@ MatrixBaseApis.prototype.updateGroupRoomVisibility = function(groupId, roomId, i

    const path = utils.encodeUri(
        "/groups/$groupId/admin/rooms/$roomId/config/m.visibility",
-        {$groupId: groupId, $roomId: roomId},
+        { $groupId: groupId, $roomId: roomId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined,
        { type: isPublic ? "public" : "private" },
@@ -821,7 +838,7 @@ MatrixBaseApis.prototype.updateGroupRoomVisibility = function(groupId, roomId, i
 MatrixBaseApis.prototype.removeRoomFromGroup = function(groupId, roomId) {
    const path = utils.encodeUri(
        "/groups/$groupId/admin/rooms/$roomId",
-        {$groupId: groupId, $roomId: roomId},
+        { $groupId: groupId, $roomId: roomId },
    );
    return this._http.authedRequest(undefined, "DELETE", path, undefined, {});
 };
@@ -835,7 +852,7 @@ MatrixBaseApis.prototype.removeRoomFromGroup = function(groupId, roomId) {
 MatrixBaseApis.prototype.acceptGroupInvite = function(groupId, opts = null) {
    const path = utils.encodeUri(
        "/groups/$groupId/self/accept_invite",
-        {$groupId: groupId},
+        { $groupId: groupId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined, opts || {});
 };
@@ -848,7 +865,7 @@ MatrixBaseApis.prototype.acceptGroupInvite = function(groupId, opts = null) {
 MatrixBaseApis.prototype.joinGroup = function(groupId) {
    const path = utils.encodeUri(
        "/groups/$groupId/self/join",
-        {$groupId: groupId},
+        { $groupId: groupId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined, {});
 };
@@ -861,7 +878,7 @@ MatrixBaseApis.prototype.joinGroup = function(groupId) {
 MatrixBaseApis.prototype.leaveGroup = function(groupId) {
    const path = utils.encodeUri(
        "/groups/$groupId/self/leave",
-        {$groupId: groupId},
+        { $groupId: groupId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined, {});
 };
@@ -918,7 +935,7 @@ MatrixBaseApis.prototype.getPublicisedGroups = function(userIds) {
 MatrixBaseApis.prototype.setGroupPublicity = function(groupId, isPublic) {
    const path = utils.encodeUri(
        "/groups/$groupId/self/update_publicity",
-        {$groupId: groupId},
+        { $groupId: groupId },
    );
    return this._http.authedRequest(undefined, "PUT", path, undefined, {
        publicise: isPublic,
@@ -986,7 +1003,7 @@ MatrixBaseApis.prototype.roomInitialSync = function(roomId, limit, callback) {
        callback = limit; limit = undefined;
    }
    const path = utils.encodeUri("/rooms/$roomId/initialSync",
-        {$roomId: roomId},
+        { $roomId: roomId },
    );
    if (!limit) {
        limit = 30;
@@ -1137,7 +1154,7 @@ MatrixBaseApis.prototype.deleteAlias = function(alias, callback) {
 MatrixBaseApis.prototype.unstableGetLocalAliases =
 function(roomId, callback) {
    const path = utils.encodeUri("/rooms/$roomId/aliases",
-        {$roomId: roomId});
+        { $roomId: roomId });
    const prefix = PREFIX_UNSTABLE + "/org.matrix.msc2432";
    return this._http.authedRequest(callback, "GET", path,
        null, null, { prefix });
@@ -1168,7 +1185,7 @@ MatrixBaseApis.prototype.getRoomIdForAlias = function(alias, callback) {
 */
 MatrixBaseApis.prototype.resolveRoomAlias = function(roomAlias, callback) {
    // TODO: deprecate this or getRoomIdForAlias
-    const path = utils.encodeUri("/directory/room/$alias", {$alias: roomAlias});
+    const path = utils.encodeUri("/directory/room/$alias", { $alias: roomAlias });
    return this._http.request(callback, "GET", path);
 };

@@ -1256,7 +1273,6 @@ MatrixBaseApis.prototype.searchUserDirectory = function(opts) {
    );
 };

-
 // Media operations
 // ================

@@ -1325,7 +1341,6 @@ MatrixBaseApis.prototype.getCurrentUploads = function() {
    return this._http.getCurrentUploads();
 };

-
 // Profile operations
 // ==================

@@ -1350,7 +1365,6 @@ MatrixBaseApis.prototype.getProfileInfo = function(userId, info, callback) {
    return this._http.authedRequest(callback, "GET", path);
 };

-
 // Account operations
 // ==================

@@ -1496,7 +1510,6 @@ MatrixBaseApis.prototype.setPassword = function(authDict, newPassword, callback)
    );
 };

-
 // Device operations
 // =================

@@ -1511,6 +1524,21 @@ MatrixBaseApis.prototype.getDevices = function() {
    );
 };

+/**
+ * Gets specific device details for the logged-in user
+ * @param {string} device_id  device to query
+ * @return {Promise} Resolves: result object
+ * @return {module:http-api.MatrixError} Rejects: with an error response.
+ */
+MatrixBaseApis.prototype.getDevice = function(device_id) {
+    const path = utils.encodeUri("/devices/$device_id", {
+        $device_id: device_id,
+    });
+    return this._http.authedRequest(
+        undefined, 'GET', path, undefined, undefined,
+    );
+};
+
 /**
 * Update the given device
 *
@@ -1558,7 +1586,7 @@ MatrixBaseApis.prototype.deleteDevice = function(device_id, auth) {
 * @return {module:http-api.MatrixError} Rejects: with an error response.
 */
 MatrixBaseApis.prototype.deleteMultipleDevices = function(devices, auth) {
-    const body = {devices};
+    const body = { devices };

    if (auth) {
        body.auth = auth;
@@ -1568,7 +1596,6 @@ MatrixBaseApis.prototype.deleteMultipleDevices = function(devices, auth) {
    return this._http.authedRequest(undefined, "POST", path, undefined, body);
 };

-
 // Push operations
 // ===============

@@ -1666,7 +1693,7 @@ MatrixBaseApis.prototype.setPushRuleEnabled = function(scope, kind,
        $ruleId: ruleId,
    });
    return this._http.authedRequest(
-        callback, "PUT", path, undefined, {"enabled": enabled},
+        callback, "PUT", path, undefined, { "enabled": enabled },
    );
 };

@@ -1687,11 +1714,10 @@ MatrixBaseApis.prototype.setPushRuleActions = function(scope, kind,
        $ruleId: ruleId,
    });
    return this._http.authedRequest(
-        callback, "PUT", path, undefined, {"actions": actions},
+        callback, "PUT", path, undefined, { "actions": actions },
    );
 };

-
 // Search
 // ======

@@ -1805,7 +1831,7 @@ MatrixBaseApis.prototype.claimOneTimeKeys = function(devices, key_algorithm, tim
        queries[userId] = query;
        query[deviceId] = key_algorithm;
    }
-    const content = {one_time_keys: queries};
+    const content = { one_time_keys: queries };
    if (timeout) {
        content.timeout = timeout;
    }
@@ -1835,7 +1861,7 @@ MatrixBaseApis.prototype.getKeyChanges = function(oldToken, newToken) {

 MatrixBaseApis.prototype.uploadDeviceSigningKeys = function(auth, keys) {
    const data = Object.assign({}, keys);
-    if (auth) Object.assign(data, {auth});
+    if (auth) Object.assign(data, { auth });
    return this._http.authedRequest(
        undefined, "POST", "/keys/device_signing/upload", undefined, data, {
            prefix: PREFIX_UNSTABLE,
@@ -2129,7 +2155,7 @@ MatrixBaseApis.prototype.identityHashedLookup = async function(
            throw new Error("Identity server returned more results than expected");
        }

-        foundAddresses.push({address: plainAddress, mxid});
+        foundAddresses.push({ address: plainAddress, mxid });
    }
    return foundAddresses;
 };
@@ -2220,7 +2246,7 @@ MatrixBaseApis.prototype.bulkLookupThreePids = async function(
        ]);
    }

-    return {threepids: v1results};
+    return { threepids: v1results };
 };

 /**
@@ -2364,6 +2390,38 @@ MatrixBaseApis.prototype.reportEvent = function(roomId, eventId, score, reason)
        $eventId: eventId,
    });

-    return this._http.authedRequest(undefined, "POST", path, null, {score, reason});
+    return this._http.authedRequest(undefined, "POST", path, null, { score, reason });
 };

+/**
+ * Fetches or paginates a summary of a space as defined by MSC2946
+ * @param {string} roomId The ID of the space-room to use as the root of the summary.
+ * @param {number?} maxRoomsPerSpace The maximum number of rooms to return per subspace.
+ * @param {boolean?} suggestedOnly Whether to only return rooms with suggested=true.
+ * @param {boolean?} autoJoinOnly Whether to only return rooms with auto_join=true.
+ * @param {number?} limit The maximum number of rooms to return in total.
+ * @param {string?} batch The opaque token to paginate a previous summary request.
+ * @returns {Promise} the response, with next_batch, rooms, events fields.
+ */
+MatrixBaseApis.prototype.getSpaceSummary = function(
+    roomId,
+    maxRoomsPerSpace,
+    suggestedOnly,
+    autoJoinOnly,
+    limit,
+    batch,
+) {
+    const path = utils.encodeUri("/rooms/$roomId/spaces", {
+        $roomId: roomId,
+    });
+
+    return this._http.authedRequest(undefined, "POST", path, null, {
+        max_rooms_per_space: maxRoomsPerSpace,
+        suggested_only: suggestedOnly,
+        auto_join_only: autoJoinOnly,
+        limit,
+        batch,
+    }, {
+        prefix: "/_matrix/client/unstable/org.matrix.msc2946",
+    });
+};
@@ -59,7 +59,7 @@ export function getHttpUriForMxc(baseUrl, mxc, width, height,
    if (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/";
@@ -72,6 +72,6 @@ export function getHttpUriForMxc(baseUrl, mxc, width, height,
        serverAndMediaId = serverAndMediaId.substr(0, fragmentOffset);
    }
    return baseUrl + prefix + serverAndMediaId +
-        (utils.keys(params).length === 0 ? "" :
+        (Object.keys(params).length === 0 ? "" :
        ("?" + utils.encodeParams(params))) + fragment;
 }
@@ -20,11 +20,11 @@ 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 {decryptAES, encryptAES} from './aes';
+import { decodeBase64, encodeBase64, pkSign, pkVerify } from './olmlib';
+import { EventEmitter } from 'events';
+import { logger } from '../logger';
+import { IndexedDBCryptoStore } from '../crypto/store/indexeddb-crypto-store';
+import { decryptAES, encryptAES } from './aes';

 const KEY_REQUEST_TIMEOUT_MS = 1000 * 60;

@@ -22,14 +22,13 @@ limitations under the License.
 * Manages the list of other users' devices
 */

-import {EventEmitter} from 'events';
-import {logger} from '../logger';
-import {DeviceInfo} from './deviceinfo';
-import {CrossSigningInfo} from './CrossSigning';
+import { EventEmitter } from 'events';
+import { logger } from '../logger';
+import { DeviceInfo } from './deviceinfo';
+import { CrossSigningInfo } from './CrossSigning';
 import * as olmlib from './olmlib';
-import {IndexedDBCryptoStore} from './store/indexeddb-crypto-store';
-import {defer, sleep} from '../utils';
-
+import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
+import { chunkPromises, defer, sleep } from '../utils';

 /* State transition diagram for DeviceList._deviceTrackingStatus
 *
@@ -51,7 +50,6 @@ import {defer, sleep} from '../utils';
 *   +----------------------- UP_TO_DATE ------------------------+
 */

-
 // constants for DeviceList._deviceTrackingStatus
 const TRACKING_STATUS_NOT_TRACKED = 0;
 const TRACKING_STATUS_PENDING_DOWNLOAD = 1;
@@ -62,7 +60,7 @@ const TRACKING_STATUS_UP_TO_DATE = 3;
 * @alias module:crypto/DeviceList
 */
 export class DeviceList extends EventEmitter {
-    constructor(baseApis, cryptoStore, olmDevice) {
+    constructor(baseApis, cryptoStore, olmDevice, keyDownloadChunkSize = 250) {
        super();

        this._cryptoStore = cryptoStore;
@@ -98,6 +96,9 @@ export class DeviceList extends EventEmitter {
        // userId -> promise
        this._keyDownloadsInProgressByUser = {};

+        // Maximum number of user IDs per request to prevent server overload (#1619)
+        this._keyDownloadChunkSize = keyDownloadChunkSize;
+
        // Set whenever changes are made other than setting the sync token
        this._dirty = false;

@@ -780,13 +781,17 @@ class DeviceListUpdateSerialiser {
            opts.token = this._syncToken;
        }

-        this._baseApis.downloadKeysForUsers(
-            downloadUsers, opts,
-        ).then(async (res) => {
-            const dk = res.device_keys || {};
-            const masterKeys = res.master_keys || {};
-            const ssks = res.self_signing_keys || {};
-            const usks = res.user_signing_keys || {};
+        const factories = [];
+        for (let i = 0; i < downloadUsers.length; i += this._deviceList._keyDownloadChunkSize) {
+            const userSlice = downloadUsers.slice(i, i + this._deviceList._keyDownloadChunkSize);
+            factories.push(() => this._baseApis.downloadKeysForUsers(userSlice, opts));
+        }
+
+        chunkPromises(factories, 3).then(async (responses) => {
+            const dk = Object.assign({}, ...(responses.map(res => res.device_keys || {})));
+            const masterKeys = Object.assign({}, ...(responses.map(res => res.master_keys || {})));
+            const ssks = Object.assign({}, ...(responses.map(res => res.self_signing_keys || {})));
+            const usks = Object.assign({}, ...(responses.map(res => res.user_signing_keys || {})));

            // yield to other things that want to execute in between users, to
            // avoid wedging the CPU
@@ -885,7 +890,6 @@ class DeviceListUpdateSerialiser {
    }
 }

-
 async function _updateStoredDeviceKeysForUser(
    _olmDevice, userId, userStore, userResult, localUserId, localDeviceId,
 ) {
@@ -1,8 +1,8 @@
 import { logger } from "../logger";
-import {MatrixEvent} from "../models/event";
-import {EventEmitter} from "events";
-import {createCryptoStoreCacheCallbacks} from "./CrossSigning";
-import {IndexedDBCryptoStore} from './store/indexeddb-crypto-store';
+import { MatrixEvent } from "../models/event";
+import { EventEmitter } from "events";
+import { createCryptoStoreCacheCallbacks } from "./CrossSigning";
+import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
 import {
    PREFIX_UNSTABLE,
 } from "../http-api";
@@ -43,7 +43,7 @@ export class EncryptionSetupBuilder {
     * @param {Object} keys the new keys
     */
    addCrossSigningKeys(authUpload, keys) {
-        this._crossSigningKeys = {authUpload, keys};
+        this._crossSigningKeys = { authUpload, keys };
    }

    /**
@@ -86,7 +86,6 @@ export class EncryptionSetupBuilder {
        userSignatures[deviceId] = signature;
    }

-
    /**
     * @param {String} type
     * @param {Object} content
@@ -211,21 +210,20 @@ export class EncryptionSetupOperation {
                        algorithm: this._keyBackupInfo.algorithm,
                        auth_data: this._keyBackupInfo.auth_data,
                    },
-                    {prefix: PREFIX_UNSTABLE},
+                    { prefix: PREFIX_UNSTABLE },
                );
            } else {
                // add new key backup
                await baseApis._http.authedRequest(
                    undefined, "POST", "/room_keys/version",
                    undefined, this._keyBackupInfo,
-                    {prefix: PREFIX_UNSTABLE},
+                    { prefix: PREFIX_UNSTABLE },
                );
            }
        }
    }
 }

-
 /**
 * Catches account data set by SecretStorage during bootstrapping by
 * implementing the methods related to account data in MatrixClient
@@ -276,7 +274,7 @@ class AccountDataClientAdapter extends EventEmitter {
        // as SecretStorage listens for it while calling this method
        // and it seems to rely on this.
        return Promise.resolve().then(() => {
-            const event = new MatrixEvent({type, content});
+            const event = new MatrixEvent({ type, content });
            this.emit("accountData", event, lastEvent);
        });
    }
@@ -335,7 +333,7 @@ class SSSSCryptoCallbacks {
        // for it to the general crypto callbacks and cache it
        if (this._delegateCryptoCallbacks) {
            const result = await this._delegateCryptoCallbacks.
-                getSecretStorageKey({keys}, name);
+                getSecretStorageKey({ keys }, name);
            if (result) {
                const [keyId, privateKey] = result;
                this._privateKeys.set(keyId, privateKey);
@@ -344,14 +342,14 @@ class SSSSCryptoCallbacks {
        }
    }

-    addPrivateKey(keyId, privKey) {
+    addPrivateKey(keyId, keyInfo, privKey) {
        this._privateKeys.set(keyId, privKey);
        // Also pass along to application to cache if it wishes
        if (
            this._delegateCryptoCallbacks &&
            this._delegateCryptoCallbacks.cacheSecretStorageKey
        ) {
-            this._delegateCryptoCallbacks.cacheSecretStorageKey(keyId, privKey);
+            this._delegateCryptoCallbacks.cacheSecretStorageKey(keyId, keyInfo, privKey);
        }
    }
 }
@@ -16,8 +16,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {logger} from '../logger';
-import {IndexedDBCryptoStore} from './store/indexeddb-crypto-store';
+import { logger } from '../logger';
+import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
 import * as algorithms from './algorithms';

 // The maximum size of an event is 65K, and we base64 the content, so this is a
@@ -48,7 +48,6 @@ function checkPayloadLength(payloadString) {
    }
 }

-
 /**
 * The type of object we use for importing and exporting megolm session data.
 *
@@ -62,7 +61,6 @@ function checkPayloadLength(payloadString) {
 * @property {String} session_key Base64'ed key data
 */

-
 /**
 * Manages the olm cryptography functions. Each OlmDevice has a single
 * OlmAccount and a number of OlmSessions.
@@ -350,7 +348,7 @@ OlmDevice.prototype._unpickleSession = function(sessionInfo, func) {
    const session = new global.Olm.Session();
    try {
        session.unpickle(this._pickleKey, sessionInfo.session);
-        const unpickledSessInfo = Object.assign({}, sessionInfo, {session});
+        const unpickledSessInfo = Object.assign({}, sessionInfo, { session });

        func(unpickledSessInfo);
    } finally {
@@ -376,7 +374,6 @@ OlmDevice.prototype._saveSession = function(deviceKey, sessionInfo, txn) {
    );
 };

-
 /**
 * get an OlmUtility and call the given function
 *
@@ -393,7 +390,6 @@ OlmDevice.prototype._getUtility = function(func) {
    }
 };

-
 /**
 * Signs a message with the ed25519 key for this account.
 *
@@ -434,7 +430,6 @@ OlmDevice.prototype.getOneTimeKeys = async function() {
    return result;
 };

-
 /**
 * Get the maximum number of one-time keys we can store.
 *
@@ -545,11 +540,11 @@ OlmDevice.prototype.createOutboundSession = async function(
                }
            });
        },
+        logger.withPrefix("[createOutboundSession]"),
    );
    return newSessionId;
 };

-
 /**
 * Generate a new inbound session, given an incoming message
 *
@@ -605,12 +600,12 @@ OlmDevice.prototype.createInboundSession = async function(
                }
            });
        },
+        logger.withPrefix("[createInboundSession]"),
    );

    return result;
 };

-
 /**
 * Get a list of known session IDs for the given device
 *
@@ -619,8 +614,10 @@ OlmDevice.prototype.createInboundSession = async function(
 * @return {Promise<string[]>}  a list of known session ids for the device
 */
 OlmDevice.prototype.getSessionIdsForDevice = async function(theirDeviceIdentityKey) {
+    const log = logger.withPrefix("[getSessionIdsForDevice]");
+
    if (this._sessionsInProgress[theirDeviceIdentityKey]) {
-        logger.log("waiting for olm session to be created");
+        log.debug(`Waiting for Olm session for ${theirDeviceIdentityKey} to be created`);
        try {
            await this._sessionsInProgress[theirDeviceIdentityKey];
        } catch (e) {
@@ -638,6 +635,7 @@ OlmDevice.prototype.getSessionIdsForDevice = async function(theirDeviceIdentityK
                },
            );
        },
+        log,
    );

    return sessionIds;
@@ -651,13 +649,14 @@ OlmDevice.prototype.getSessionIdsForDevice = async function(theirDeviceIdentityK
 * @param {boolean} nowait Don't wait for an in-progress session to complete.
 *     This should only be set to true of the calling function is the function
 *     that marked the session as being in-progress.
+ * @param {Logger} [log] A possibly customised log
 * @return {Promise<?string>}  session id, or null if no established session
 */
 OlmDevice.prototype.getSessionIdForDevice = async function(
-    theirDeviceIdentityKey, nowait,
+    theirDeviceIdentityKey, nowait, log,
 ) {
    const sessionInfos = await this.getSessionInfoForDevice(
-        theirDeviceIdentityKey, nowait,
+        theirDeviceIdentityKey, nowait, log,
    );

    if (sessionInfos.length === 0) {
@@ -697,11 +696,16 @@ OlmDevice.prototype.getSessionIdForDevice = async function(
 * @param {boolean} nowait Don't wait for an in-progress session to complete.
 *     This should only be set to true of the calling function is the function
 *     that marked the session as being in-progress.
+ * @param {Logger} [log] A possibly customised log
 * @return {Array.<{sessionId: string, hasReceivedMessage: Boolean}>}
 */
-OlmDevice.prototype.getSessionInfoForDevice = async function(deviceIdentityKey, nowait) {
+OlmDevice.prototype.getSessionInfoForDevice = async function(
+    deviceIdentityKey, nowait, log = logger,
+) {
+    log = log.withPrefix("[getSessionInfoForDevice]");
+
    if (this._sessionsInProgress[deviceIdentityKey] && !nowait) {
-        logger.log("waiting for olm session to be created");
+        log.debug(`Waiting for Olm session for ${deviceIdentityKey} to be created`);
        try {
            await this._sessionsInProgress[deviceIdentityKey];
        } catch (e) {
@@ -727,6 +731,7 @@ OlmDevice.prototype.getSessionInfoForDevice = async function(deviceIdentityKey,
                }
            });
        },
+        log,
    );

    return info;
@@ -761,6 +766,7 @@ OlmDevice.prototype.encryptMessage = async function(
                this._saveSession(theirDeviceIdentityKey, sessionInfo, txn);
            });
        },
+        logger.withPrefix("[encryptMessage]"),
    );
    return res;
 };
@@ -794,6 +800,7 @@ OlmDevice.prototype.decryptMessage = async function(
                this._saveSession(theirDeviceIdentityKey, sessionInfo, txn);
            });
        },
+        logger.withPrefix("[decryptMessage]"),
    );
    return payloadString;
 };
@@ -825,6 +832,7 @@ OlmDevice.prototype.matchesSession = async function(
                matches = sessionInfo.session.matches_inbound(ciphertext);
            });
        },
+        logger.withPrefix("[matchesSession]"),
    );
    return matches;
 };
@@ -841,7 +849,6 @@ OlmDevice.prototype.filterOutNotifiedErrorDevices = async function(devices) {
    return await this._cryptoStore.filterOutNotifiedErrorDevices(devices);
 };

-
 // Outbound group session
 // ======================

@@ -856,7 +863,6 @@ OlmDevice.prototype._saveOutboundGroupSession = function(session) {
    this._outboundGroupSessionStore[session.session_id()] = pickledSession;
 };

-
 /**
 * extract an OutboundGroupSession from _outboundGroupSessionStore and call the
 * given function
@@ -881,7 +887,6 @@ OlmDevice.prototype._getOutboundGroupSession = function(sessionId, func) {
    }
 };

-
 /**
 * Generate a new outbound group session
 *
@@ -898,7 +903,6 @@ OlmDevice.prototype.createOutboundGroupSession = function() {
    }
 };

-
 /**
 * Encrypt an outgoing message with an outbound group session
 *
@@ -938,7 +942,6 @@ OlmDevice.prototype.getOutboundGroupSessionKey = function(sessionId) {
    });
 };

-
 // Inbound group session
 // =====================

@@ -1033,6 +1036,7 @@ OlmDevice.prototype.addInboundGroupSession = async function(
        'readwrite', [
            IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS,
            IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD,
+            IndexedDBCryptoStore.STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS,
        ], (txn) => {
            /* if we already have this session, consider updating it */
            this._getInboundGroupSession(
@@ -1059,9 +1063,14 @@ OlmDevice.prototype.addInboundGroupSession = async function(
                                    + senderKey + "/" + sessionId,
                            );
                            if (existingSession.first_known_index()
-                                <= session.first_known_index()) {
+                                <= session.first_known_index()
+                                && !(existingSession.first_known_index() == session.first_known_index()
+                                    && !extraSessionData.untrusted
+                                    && existingSessionData.untrusted)) {
                                // existing session has lower index (i.e. can
-                                // decrypt more), so keep it
+                                // decrypt more), or they have the same index and
+                                // the new sessions trust does not win over the old
+                                // sessions trust, so keep it
                                logger.log(
                                    `Keeping existing megolm session ${sessionId}`,
                                );
@@ -1084,12 +1093,19 @@ OlmDevice.prototype.addInboundGroupSession = async function(
                        this._cryptoStore.storeEndToEndInboundGroupSession(
                            senderKey, sessionId, sessionData, txn,
                        );
+
+                        if (!existingSession && extraSessionData.sharedHistory) {
+                            this._cryptoStore.addSharedHistoryInboundGroupSession(
+                                roomId, senderKey, sessionId, txn,
+                            );
+                        }
                    } finally {
                        session.free();
                    }
                },
            );
        },
+        logger.withPrefix("[addInboundGroupSession]"),
    );
 };

@@ -1260,6 +1276,7 @@ OlmDevice.prototype.decryptGroupMessage = async function(
                },
            );
        },
+        logger.withPrefix("[decryptGroupMessage]"),
    );

    if (error) {
@@ -1305,6 +1322,7 @@ OlmDevice.prototype.hasInboundSessionKeys = async function(roomId, senderKey, se
                },
            );
        },
+        logger.withPrefix("[hasInboundSessionKeys]"),
    );

    return result;
@@ -1360,10 +1378,12 @@ OlmDevice.prototype.getInboundGroupSessionKey = async function(
                        "forwarding_curve25519_key_chain":
                            sessionData.forwardingCurve25519KeyChain || [],
                        "sender_claimed_ed25519_key": senderEd25519Key,
+                        "shared_history": sessionData.sharedHistory || false,
                    };
                },
            );
        },
+        logger.withPrefix("[getInboundGroupSessionKey]"),
    );

    return result;
@@ -1391,10 +1411,24 @@ OlmDevice.prototype.exportInboundGroupSession = function(
            "session_key": session.export_session(messageIndex),
            "forwarding_curve25519_key_chain": session.forwardingCurve25519KeyChain || [],
            "first_known_index": session.first_known_index(),
+            "org.matrix.msc3061.shared_history": sessionData.sharedHistory || false,
        };
    });
 };

+OlmDevice.prototype.getSharedHistoryInboundGroupSessions = async function(roomId) {
+    let result;
+    await this._cryptoStore.doTxn(
+        'readonly', [
+            IndexedDBCryptoStore.STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS,
+        ], (txn) => {
+            result = this._cryptoStore.getSharedHistoryInboundGroupSessions(roomId, txn);
+        },
+        logger.withPrefix("[getSharedHistoryInboundGroupSessionsForRoom]"),
+    );
+    return result;
+};
+
 // Utilities
 // =========

@@ -14,8 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {logger} from '../logger';
-import * as utils from '../utils';
+import { logger } from '../logger';

 /**
 * Internal module. Management of outgoing room key requests.
@@ -496,7 +495,7 @@ function stringifyRequestBody(requestBody) {

 function stringifyRecipientList(recipients) {
    return '['
-        + utils.map(recipients, (r) => `${r.userId}:${r.deviceId}`).join(",")
+        + recipients.map((r) => `${r.userId}:${r.deviceId}`).join(",")
        + ']';
 }

@@ -20,7 +20,7 @@ limitations under the License.
 * Manages the list of encrypted rooms
 */

-import {IndexedDBCryptoStore} from './store/indexeddb-crypto-store';
+import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';

 /**
 * @alias module:crypto/RoomList
@@ -14,12 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {EventEmitter} from 'events';
-import {logger} from '../logger';
+import { EventEmitter } from 'events';
+import { logger } from '../logger';
 import * as olmlib from './olmlib';
-import {randomString} from '../randomstring';
-import {encryptAES, decryptAES} from './aes';
-import {encodeBase64} from "./olmlib";
+import { randomString } from '../randomstring';
+import { encryptAES, decryptAES } from './aes';
+import { encodeBase64 } from "./olmlib";

 export const SECRET_STORAGE_ALGORITHM_V1_AES
    = "m.secret_storage.v1.aes-hmac-sha2";
@@ -81,25 +81,27 @@ export class SecretStorage extends EventEmitter {
     * @param {string} [keyId] the ID of the key.  If not given, a random
     *     ID will be generated.
     *
-     * @return {string} the ID of the key
+     * @return {object} An object with:
+     *     keyId: {string} the ID of the key
+     *     keyInfo: {object} details about the key (iv, mac, passphrase)
     */
    async addKey(algorithm, opts, keyId) {
-        const keyData = {algorithm};
+        const keyInfo = { algorithm };

        if (!opts) opts = {};

        if (opts.name) {
-            keyData.name = opts.name;
+            keyInfo.name = opts.name;
        }

        if (algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {
            if (opts.passphrase) {
-                keyData.passphrase = opts.passphrase;
+                keyInfo.passphrase = opts.passphrase;
            }
            if (opts.key) {
-                const {iv, mac} = await SecretStorage._calculateKeyCheck(opts.key);
-                keyData.iv = iv;
-                keyData.mac = mac;
+                const { iv, mac } = await SecretStorage._calculateKeyCheck(opts.key);
+                keyInfo.iv = iv;
+                keyInfo.mac = mac;
            }
        } else {
            throw new Error(`Unknown key algorithm ${opts.algorithm}`);
@@ -116,10 +118,13 @@ export class SecretStorage extends EventEmitter {
        }

        await this._baseApis.setAccountData(
-            `m.secret_storage.key.${keyId}`, keyData,
+            `m.secret_storage.key.${keyId}`, keyInfo,
        );

-        return keyId;
+        return {
+            keyId,
+            keyInfo,
+        };
    }

    /**
@@ -166,7 +171,7 @@ export class SecretStorage extends EventEmitter {
    async checkKey(key, info) {
        if (info.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {
            if (info.mac) {
-                const {mac} = await SecretStorage._calculateKeyCheck(key, info.iv);
+                const { mac } = await SecretStorage._calculateKeyCheck(key, info.iv);
                return info.mac.replace(/=+$/g, '') === mac.replace(/=+$/g, '');
            } else {
                // if we have no information, we have to assume the key is right
@@ -215,7 +220,7 @@ export class SecretStorage extends EventEmitter {

            // encrypt secret, based on the algorithm
            if (keyInfo.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {
-                const keys = {[keyId]: keyInfo};
+                const keys = { [keyId]: keyInfo };
                const [, encryption] = await this._getSecretStorageKey(keys, name);
                encrypted[keyId] = await encryption.encrypt(secret);
            } else {
@@ -226,7 +231,7 @@ export class SecretStorage extends EventEmitter {
        }

        // save encrypted secret
-        await this._baseApis.setAccountData(name, {encrypted});
+        await this._baseApis.setAccountData(name, { encrypted });
    }

    /**
@@ -457,13 +462,13 @@ export class SecretStorage extends EventEmitter {
            if (!this._cryptoCallbacks.onSecretRequested) {
                return;
            }
-            const secret = await this._cryptoCallbacks.onSecretRequested({
-                user_id: sender,
-                device_id: deviceId,
-                request_id: content.request_id,
-                name: content.name,
-                device_trust: this._baseApis.checkDeviceTrust(sender, deviceId),
-            });
+            const secret = await this._cryptoCallbacks.onSecretRequested(
+                sender,
+                deviceId,
+                content.request_id,
+                content.name,
+                this._baseApis.checkDeviceTrust(sender, deviceId),
+            );
            if (secret) {
                logger.info(`Preparing ${content.name} secret for ${deviceId}`);
                const payload = {
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {getCrypto} from '../utils';
-import {decodeBase64, encodeBase64} from './olmlib';
+import { getCrypto } from '../utils';
+import { decodeBase64, encodeBase64 } from './olmlib';

 const subtleCrypto = (typeof window !== "undefined" && window.crypto) ?
    (window.crypto.subtle || window.crypto.webkitSubtle) : null;
@@ -148,7 +148,7 @@ async function encryptBrowser(data, key, name, ivStr) {
    );

    const hmac = await subtleCrypto.sign(
-        {name: 'HMAC'},
+        { name: 'HMAC' },
        hmacKey,
        ciphertext,
    );
@@ -176,7 +176,7 @@ async function decryptBrowser(data, key, name) {
    const ciphertext = decodeBase64(data.ciphertext);

    if (!await subtleCrypto.verify(
-        {name: "HMAC"},
+        { name: "HMAC" },
        hmacKey,
        decodeBase64(data.mac),
        ciphertext,
@@ -201,7 +201,7 @@ async function deriveKeysBrowser(key, name) {
    const hkdfkey = await subtleCrypto.importKey(
        'raw',
        key,
-        {name: "HKDF"},
+        { name: "HKDF" },
        false,
        ["deriveBits"],
    );
@@ -222,7 +222,7 @@ async function deriveKeysBrowser(key, name) {
    const aesProm = subtleCrypto.importKey(
        'raw',
        aesKey,
-        {name: 'AES-CTR'},
+        { name: 'AES-CTR' },
        false,
        ['encrypt', 'decrypt'],
    );
@@ -232,7 +232,7 @@ async function deriveKeysBrowser(key, name) {
        hmacKey,
        {
            name: 'HMAC',
-            hash: {name: 'SHA-256'},
+            hash: { name: 'SHA-256' },
        },
        false,
        ['sign', 'verify'],
@@ -22,9 +22,9 @@ limitations under the License.
 * @module crypto/algorithms/megolm
 */

-import {logger} from '../../logger';
+import { logger } from '../../logger';
 import * as utils from "../../utils";
-import {polyfillSuper} from "../../utils";
+import { polyfillSuper } from "../../utils";
 import * as olmlib from "../olmlib";
 import {
    DecryptionAlgorithm,
@@ -34,13 +34,29 @@ import {
    UnknownDeviceError,
 } from "./base";

-import {WITHHELD_MESSAGES} from '../OlmDevice';
+import { WITHHELD_MESSAGES } from '../OlmDevice';
+
+// determine whether the key can be shared with invitees
+function isRoomSharedHistory(room) {
+    const visibilityEvent = room.currentState &&
+          room.currentState.getStateEvents("m.room.history_visibility", "");
+    // NOTE: if the room visibility is unset, it would normally default to
+    // "world_readable".
+    // (https://spec.matrix.org/unstable/client-server-api/#server-behaviour-5)
+    // But we will be paranoid here, and treat it as a situation where the room
+    // is not shared-history
+    const visibility = visibilityEvent && visibilityEvent.getContent() &&
+          visibilityEvent.getContent().history_visibility;
+    return ["world_readable", "shared"].includes(visibility);
+}

 /**
 * @private
 * @constructor
 *
 * @param {string} sessionId
+ * @param {boolean} sharedHistory whether the session can be freely shared with
+ *    other group members, according to the room history visibility settings
 *
 * @property {string} sessionId
 * @property {Number} useCount     number of times this session has been used
@@ -50,15 +66,15 @@ import {WITHHELD_MESSAGES} from '../OlmDevice';
 *    devices with which we have shared the session key
 *        userId -> {deviceId -> msgindex}
 */
-function OutboundSessionInfo(sessionId) {
+function OutboundSessionInfo(sessionId, sharedHistory = false) {
    this.sessionId = sessionId;
    this.useCount = 0;
    this.creationTime = new Date().getTime();
    this.sharedWithDevices = {};
    this.blockedDevicesNotified = {};
+    this.sharedHistory = sharedHistory;
 }

-
 /**
 * Check if it's time to rotate the session
 *
@@ -141,7 +157,6 @@ OutboundSessionInfo.prototype.sharedWithTooManyDevices = function(
    }
 };

-
 /**
 * Megolm encryption implementation
 *
@@ -183,6 +198,7 @@ utils.inherits(MegolmEncryption, EncryptionAlgorithm);
 /**
 * @private
 *
+ * @param {module:models/room} room
 * @param {Object} devicesInRoom The devices in this room, indexed by user ID
 * @param {Object} blocked The devices that are blocked, indexed by user ID
 * @param {boolean} [singleOlmCreationPhase] Only perform one round of olm
@@ -192,7 +208,7 @@ utils.inherits(MegolmEncryption, EncryptionAlgorithm);
 *    OutboundSessionInfo when setup is complete.
 */
 MegolmEncryption.prototype._ensureOutboundSession = async function(
-    devicesInRoom, blocked, singleOlmCreationPhase,
+    room, devicesInRoom, blocked, singleOlmCreationPhase,
 ) {
    let session;

@@ -204,6 +220,13 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(
    const prepareSession = async (oldSession) => {
        session = oldSession;

+        const sharedHistory = isRoomSharedHistory(room);
+
+        // history visibility changed
+        if (session && sharedHistory !== session.sharedHistory) {
+            session = null;
+        }
+
        // need to make a brand new session?
        if (session && session.needsRotation(this._sessionRotationPeriodMsgs,
                                             this._sessionRotationPeriodMs)
@@ -219,7 +242,7 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(

        if (!session) {
            logger.log(`Starting new megolm session for room ${this._roomId}`);
-            session = await this._prepareNewSession();
+            session = await this._prepareNewSession(sharedHistory);
            logger.log(`Started new megolm session ${session.sessionId} ` +
                       `for room ${this._roomId}`);
            this._outboundSessions[session.sessionId] = session;
@@ -250,11 +273,12 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(
        const payload = {
            type: "m.room_key",
            content: {
-                algorithm: olmlib.MEGOLM_ALGORITHM,
-                room_id: this._roomId,
-                session_id: session.sessionId,
-                session_key: key.key,
-                chain_index: key.chain_index,
+                "algorithm": olmlib.MEGOLM_ALGORITHM,
+                "room_id": this._roomId,
+                "session_id": session.sessionId,
+                "session_key": key.key,
+                "chain_index": key.chain_index,
+                "org.matrix.msc3061.shared_history": sharedHistory,
            },
        };
        const [devicesWithoutSession, olmSessions] = await olmlib.getExistingOlmSessions(
@@ -264,11 +288,14 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(
        await Promise.all([
            (async () => {
                // share keys with devices that we already have a session for
+                logger.debug(`Sharing keys with existing Olm sessions in ${this._roomId}`);
                await this._shareKeyWithOlmSessions(
                    session, key, payload, olmSessions,
                );
+                logger.debug(`Shared keys with existing Olm sessions in ${this._roomId}`);
            })(),
            (async () => {
+                logger.debug(`Sharing keys (start phase 1) with new Olm sessions in ${this._roomId}`);
                const errorDevices = [];

                // meanwhile, establish olm sessions for devices that we don't
@@ -282,6 +309,7 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(
                    session, key, payload, devicesWithoutSession, errorDevices,
                    singleOlmCreationPhase ? 10000 : 2000, failedServers,
                );
+                logger.debug(`Shared keys (end phase 1) with new Olm sessions in ${this._roomId}`);

                if (!singleOlmCreationPhase && (Date.now() - start < 10000)) {
                    // perform the second phase of olm session creation if requested,
@@ -298,7 +326,7 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(
                            failedServerMap.add(server);
                        }
                        const failedDevices = [];
-                        for (const {userId, deviceInfo} of errorDevices) {
+                        for (const { userId, deviceInfo } of errorDevices) {
                            const userHS = userId.slice(userId.indexOf(":") + 1);
                            if (failedServerMap.has(userHS)) {
                                retryDevices[userId] = retryDevices[userId] || [];
@@ -306,23 +334,28 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(
                            } else {
                                // if we aren't going to retry, then handle it
                                // as a failed device
-                                failedDevices.push({userId, deviceInfo});
+                                failedDevices.push({ userId, deviceInfo });
                            }
                        }

+                        logger.debug(`Sharing keys (start phase 2) with new Olm sessions in ${this._roomId}`);
                        await this._shareKeyWithDevices(
                            session, key, payload, retryDevices, failedDevices, 30000,
                        );
+                        logger.debug(`Shared keys (end phase 2) with new Olm sessions in ${this._roomId}`);

                        await this._notifyFailedOlmDevices(session, key, failedDevices);
                    })();
                } else {
                    await this._notifyFailedOlmDevices(session, key, errorDevices);
                }
+                logger.debug(`Shared keys (all phases done) with new Olm sessions in ${this._roomId}`);
            })(),
            (async () => {
+                logger.debug(`Notifying blocked devices in ${this._roomId}`);
                // also, notify blocked devices that they're blocked
                const blockedMap = {};
+                let blockedCount = 0;
                for (const [userId, userBlockedDevices] of Object.entries(blocked)) {
                    for (const [deviceId, device] of Object.entries(userBlockedDevices)) {
                        if (
@@ -330,12 +363,14 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(
                            session.blockedDevicesNotified[userId][deviceId] === undefined
                        ) {
                            blockedMap[userId] = blockedMap[userId] || {};
-                            blockedMap[userId][deviceId] = {device};
+                            blockedMap[userId][deviceId] = { device };
+                            blockedCount++;
                        }
                    }
                }

                await this._notifyBlockedDevices(session, blockedMap);
+                logger.debug(`Notified ${blockedCount} blocked devices in ${this._roomId}`);
            })(),
        ]);
    };
@@ -348,6 +383,11 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(
    // first wait for the previous share to complete
    const prom = this._setupPromise.then(prepareSession);

+    // Ensure any failures are logged for debugging
+    prom.catch(e => {
+        logger.error(`Failed to ensure outbound session in ${this._roomId}`, e);
+    });
+
    // _setupPromise resolves to `session` whether or not the share succeeds
    this._setupPromise = prom.then(returnSession, returnSession);

@@ -358,30 +398,27 @@ MegolmEncryption.prototype._ensureOutboundSession = async function(
 /**
 * @private
 *
+ * @param {boolean} sharedHistory
+ *
 * @return {module:crypto/algorithms/megolm.OutboundSessionInfo} session
 */
-MegolmEncryption.prototype._prepareNewSession = async function() {
+MegolmEncryption.prototype._prepareNewSession = async function(sharedHistory) {
    const sessionId = this._olmDevice.createOutboundGroupSession();
    const key = this._olmDevice.getOutboundGroupSessionKey(sessionId);

    await this._olmDevice.addInboundGroupSession(
        this._roomId, this._olmDevice.deviceCurve25519Key, [], sessionId,
-        key.key, {ed25519: this._olmDevice.deviceEd25519Key},
+        key.key, { ed25519: this._olmDevice.deviceEd25519Key }, false,
+        { sharedHistory: sharedHistory },
    );

-    if (this._crypto.backupInfo) {
-        // don't wait for it to complete
-        this._crypto.backupGroupSession(
-            this._roomId, this._olmDevice.deviceCurve25519Key, [],
-            sessionId, key.key,
-        ).catch((e) => {
-            // This throws if the upload failed, but this is fine
-            // since it will have written it to the db and will retry.
-            logger.log("Failed to back up megolm session", e);
-        });
-    }
+    // don't wait for it to complete
+    this._crypto.backupGroupSession(
+        this._roomId, this._olmDevice.deviceCurve25519Key, [],
+        sessionId, key.key,
+    );

-    return new OutboundSessionInfo(sessionId);
+    return new OutboundSessionInfo(sessionId, sharedHistory);
 };

 /**
@@ -415,7 +452,7 @@ MegolmEncryption.prototype._getDevicesWithoutSessions = function(
                // no session with this device, probably because there
                // were no one-time keys.

-                noOlmDevices.push({userId, deviceInfo});
+                noOlmDevices.push({ userId, deviceInfo });
                delete sessionResults[deviceId];

                // ensureOlmSessionsForUsers has already done the logging,
@@ -662,14 +699,15 @@ MegolmEncryption.prototype.reshareKeyWithDevice = async function(
    const payload = {
        type: "m.forwarded_room_key",
        content: {
-            algorithm: olmlib.MEGOLM_ALGORITHM,
-            room_id: this._roomId,
-            session_id: sessionId,
-            session_key: key.key,
-            chain_index: key.chain_index,
-            sender_key: senderKey,
-            sender_claimed_ed25519_key: key.sender_claimed_ed25519_key,
-            forwarding_curve25519_key_chain: key.forwarding_curve25519_key_chain,
+            "algorithm": olmlib.MEGOLM_ALGORITHM,
+            "room_id": this._roomId,
+            "session_id": sessionId,
+            "session_key": key.key,
+            "chain_index": key.chain_index,
+            "sender_key": senderKey,
+            "sender_claimed_ed25519_key": key.sender_claimed_ed25519_key,
+            "forwarding_curve25519_key_chain": key.forwarding_curve25519_key_chain,
+            "org.matrix.msc3061.shared_history": key.shared_history || false,
        },
    };

@@ -723,13 +761,18 @@ MegolmEncryption.prototype.reshareKeyWithDevice = async function(
 MegolmEncryption.prototype._shareKeyWithDevices = async function(
    session, key, payload, devicesByUser, errorDevices, otkTimeout, failedServers,
 ) {
+    logger.debug(`Ensuring Olm sessions for devices in ${this._roomId}`);
    const devicemap = await olmlib.ensureOlmSessionsForDevices(
        this._olmDevice, this._baseApis, devicesByUser, otkTimeout, failedServers,
+        logger.withPrefix(`[${this._roomId}]`),
    );
+    logger.debug(`Ensured Olm sessions for devices in ${this._roomId}`);

    this._getDevicesWithoutSessions(devicemap, devicesByUser, errorDevices);

+    logger.debug(`Sharing keys with Olm sessions in ${this._roomId}`);
    await this._shareKeyWithOlmSessions(session, key, payload, devicemap);
+    logger.debug(`Shared keys with Olm sessions in ${this._roomId}`);
 };

 MegolmEncryption.prototype._shareKeyWithOlmSessions = async function(
@@ -738,16 +781,17 @@ MegolmEncryption.prototype._shareKeyWithOlmSessions = async function(
    const userDeviceMaps = this._splitDevices(devicemap);

    for (let i = 0; i < userDeviceMaps.length; i++) {
+        const taskDetail =
+            `megolm keys for ${session.sessionId} ` +
+            `in ${this._roomId} (slice ${i + 1}/${userDeviceMaps.length})`;
        try {
+            logger.debug(`Sharing ${taskDetail}`);
            await this._encryptAndSendKeysToDevices(
                session, key.chain_index, userDeviceMaps[i], payload,
            );
-            logger.log(`Completed megolm keyshare for ${session.sessionId} `
-                + `in ${this._roomId} (slice ${i + 1}/${userDeviceMaps.length})`);
+            logger.debug(`Shared ${taskDetail}`);
        } catch (e) {
-            logger.log(`megolm keyshare for ${session.sessionId} in ${this._roomId} `
-                + `(slice ${i + 1}/${userDeviceMaps.length}) failed`);
-
+            logger.error(`Failed to share ${taskDetail}`);
            throw e;
        }
    }
@@ -766,9 +810,14 @@ MegolmEncryption.prototype._shareKeyWithOlmSessions = async function(
 MegolmEncryption.prototype._notifyFailedOlmDevices = async function(
    session, key, failedDevices,
 ) {
+    logger.debug(
+        `Notifying ${failedDevices.length} devices we failed to ` +
+        `create Olm sessions in ${this._roomId}`,
+    );
+
    // mark the devices that failed as "handled" because we don't want to try
    // to claim a one-time-key for dead devices on every message.
-    for (const {userId, deviceInfo} of failedDevices) {
+    for (const { userId, deviceInfo } of failedDevices) {
        const deviceId = deviceInfo.deviceId;

        session.markSharedWithDevice(
@@ -780,8 +829,12 @@ MegolmEncryption.prototype._notifyFailedOlmDevices = async function(
          await this._olmDevice.filterOutNotifiedErrorDevices(
              failedDevices,
          );
+    logger.debug(
+        `Filtered down to ${filteredFailedDevices.length} error devices ` +
+        `in ${this._roomId}`,
+    );
    const blockedMap = {};
-    for (const {userId, deviceInfo} of filteredFailedDevices) {
+    for (const { userId, deviceInfo } of filteredFailedDevices) {
        blockedMap[userId] = blockedMap[userId] || {};
        // we use a similar format to what
        // olmlib.ensureOlmSessionsForDevices returns, so that
@@ -797,6 +850,10 @@ MegolmEncryption.prototype._notifyFailedOlmDevices = async function(

    // send the notifications
    await this._notifyBlockedDevices(session, blockedMap);
+    logger.debug(
+        `Notified ${filteredFailedDevices.length} devices we failed to ` +
+        `create Olm sessions in ${this._roomId}`,
+    );
 };

 /**
@@ -846,24 +903,41 @@ MegolmEncryption.prototype.prepareToEncrypt = function(room) {
        // We're already preparing something, so don't do anything else.
        // FIXME: check if we need to restart
        // (https://github.com/matrix-org/matrix-js-sdk/issues/1255)
+        const elapsedTime = Date.now() - this.encryptionPreparationMetadata.startTime;
+        logger.debug(
+            `Already started preparing to encrypt for ${this._roomId} ` +
+            `${elapsedTime} ms ago, skipping`,
+        );
        return;
    }

    logger.debug(`Preparing to encrypt events for ${this._roomId}`);

+    this.encryptionPreparationMetadata = {
+        startTime: Date.now(),
+    };
    this.encryptionPreparation = (async () => {
-        const [devicesInRoom, blocked] = await this._getDevicesInRoom(room);
+        try {
+            logger.debug(`Getting devices in ${this._roomId}`);
+            const [devicesInRoom, blocked] = await this._getDevicesInRoom(room);

-        if (this._crypto.getGlobalErrorOnUnknownDevices()) {
-            // Drop unknown devices for now.  When the message gets sent, we'll
-            // throw an error, but we'll still be prepared to send to the known
-            // devices.
-            this._removeUnknownDevices(devicesInRoom);
+            if (this._crypto.getGlobalErrorOnUnknownDevices()) {
+                // Drop unknown devices for now.  When the message gets sent, we'll
+                // throw an error, but we'll still be prepared to send to the known
+                // devices.
+                this._removeUnknownDevices(devicesInRoom);
+            }
+
+            logger.debug(`Ensuring outbound session in ${this._roomId}`);
+            await this._ensureOutboundSession(room, devicesInRoom, blocked, true);
+
+            logger.debug(`Ready to encrypt events for ${this._roomId}`);
+        } catch (e) {
+            logger.error(`Failed to prepare to encrypt events for ${this._roomId}`, e);
+        } finally {
+            delete this.encryptionPreparationMetadata;
+            delete this.encryptionPreparation;
        }
-
-        await this._ensureOutboundSession(devicesInRoom, blocked, true);
-
-        delete this.encryptionPreparation;
    })();
 };

@@ -899,7 +973,7 @@ MegolmEncryption.prototype.encryptMessage = async function(room, eventType, cont
        this._checkForUnknownDevices(devicesInRoom);
    }

-    const session = await this._ensureOutboundSession(devicesInRoom, blocked);
+    const session = await this._ensureOutboundSession(room, devicesInRoom, blocked);
    const payloadJson = {
        room_id: this._roomId,
        type: eventType,
@@ -1000,7 +1074,7 @@ MegolmEncryption.prototype._removeUnknownDevices = function(devicesInRoom) {
 */
 MegolmEncryption.prototype._getDevicesInRoom = async function(room) {
    const members = await room.getEncryptionTargetMembers();
-    const roomMembers = utils.map(members, function(u) {
+    const roomMembers = members.map(function(u) {
        return u.userId;
    });

@@ -1265,7 +1339,6 @@ MegolmDecryption.prototype._removeEventFromPendingList = function(event) {
    }
 };

-
 /**
 * @inheritdoc
 *
@@ -1295,7 +1368,7 @@ MegolmDecryption.prototype.onRoomKeyEvent = function(event) {
    if (event.getType() == "m.forwarded_room_key") {
        exportFormat = true;
        forwardingKeyChain = content.forwarding_curve25519_key_chain;
-        if (!utils.isArray(forwardingKeyChain)) {
+        if (!Array.isArray(forwardingKeyChain)) {
            forwardingKeyChain = [];
        }

@@ -1324,10 +1397,14 @@ MegolmDecryption.prototype.onRoomKeyEvent = function(event) {
        keysClaimed = event.getKeysClaimed();
    }

+    const extraSessionData = {};
+    if (content["org.matrix.msc3061.shared_history"]) {
+        extraSessionData.sharedHistory = true;
+    }
    return this._olmDevice.addInboundGroupSession(
        content.room_id, senderKey, forwardingKeyChain, sessionId,
        content.session_key, keysClaimed,
-        exportFormat,
+        exportFormat, extraSessionData,
    ).then(() => {
        // have another go at decrypting events sent with this session.
        this._retryDecryption(senderKey, sessionId)
@@ -1347,18 +1424,12 @@ MegolmDecryption.prototype.onRoomKeyEvent = function(event) {
                }
            });
    }).then(() => {
-        if (this._crypto.backupInfo) {
-            // don't wait for the keys to be backed up for the server
-            this._crypto.backupGroupSession(
-                content.room_id, senderKey, forwardingKeyChain,
-                content.session_id, content.session_key, keysClaimed,
-                exportFormat,
-            ).catch((e) => {
-                // This throws if the upload failed, but this is fine
-                // since it will have written it to the db and will retry.
-                logger.log("Failed to back up megolm session", e);
-            });
-        }
+        // don't wait for the keys to be backed up for the server
+        this._crypto.backupGroupSession(
+            content.room_id, senderKey, forwardingKeyChain,
+            content.session_id, content.session_key, keysClaimed,
+            exportFormat,
+        );
    }).catch((e) => {
        logger.error(`Error handling m.room_key_event: ${e}`);
    });
@@ -1415,7 +1486,7 @@ MegolmDecryption.prototype.onRoomKeyWithheldEvent = async function(event) {
            }
        }
        await olmlib.ensureOlmSessionsForDevices(
-            this._olmDevice, this._baseApis, {[sender]: [device]}, false,
+            this._olmDevice, this._baseApis, { [sender]: [device] }, false,
        );
        const encryptedContent = {
            algorithm: olmlib.OLM_ALGORITHM,
@@ -1429,7 +1500,7 @@ MegolmDecryption.prototype.onRoomKeyWithheldEvent = async function(event) {
            this._olmDevice,
            sender,
            device,
-            {type: "m.dummy"},
+            { type: "m.dummy" },
        );

        await this._olmDevice.recordSessionProblem(senderKey, "no_olm", true);
@@ -1533,14 +1604,15 @@ MegolmDecryption.prototype._buildKeyForwardingMessage = async function(
    return {
        type: "m.forwarded_room_key",
        content: {
-            algorithm: olmlib.MEGOLM_ALGORITHM,
-            room_id: roomId,
-            sender_key: senderKey,
-            sender_claimed_ed25519_key: key.sender_claimed_ed25519_key,
-            session_id: sessionId,
-            session_key: key.key,
-            chain_index: key.chain_index,
-            forwarding_curve25519_key_chain: key.forwarding_curve25519_key_chain,
+            "algorithm": olmlib.MEGOLM_ALGORITHM,
+            "room_id": roomId,
+            "sender_key": senderKey,
+            "sender_claimed_ed25519_key": key.sender_claimed_ed25519_key,
+            "session_id": sessionId,
+            "session_key": key.key,
+            "chain_index": key.chain_index,
+            "forwarding_curve25519_key_chain": key.forwarding_curve25519_key_chain,
+            "org.matrix.msc3061.shared_history": key.shared_history || false,
        },
    };
 };
@@ -1554,6 +1626,13 @@ MegolmDecryption.prototype._buildKeyForwardingMessage = async function(
 * @param {string} [opts.source] where the key came from
 */
 MegolmDecryption.prototype.importRoomKey = function(session, opts = {}) {
+    const extraSessionData = {};
+    if (opts.untrusted) {
+        extraSessionData.untrusted = true;
+    }
+    if (session["org.matrix.msc3061.shared_history"]) {
+        extraSessionData.sharedHistory = true;
+    }
    return this._olmDevice.addInboundGroupSession(
        session.room_id,
        session.sender_key,
@@ -1562,9 +1641,9 @@ MegolmDecryption.prototype.importRoomKey = function(session, opts = {}) {
        session.session_key,
        session.sender_claimed_keys,
        true,
-        opts.untrusted ? { untrusted: opts.untrusted } : {},
+        extraSessionData,
    ).then(() => {
-        if (this._crypto.backupInfo && opts.source !== "backup") {
+        if (opts.source !== "backup") {
            // don't wait for it to complete
            this._crypto.backupGroupSession(
                session.room_id,
@@ -1610,7 +1689,7 @@ MegolmDecryption.prototype._retryDecryption = async function(senderKey, sessionI

    await Promise.all([...pending].map(async (ev) => {
        try {
-            await ev.attemptDecryption(this._crypto, true);
+            await ev.attemptDecryption(this._crypto, { isRetry: true });
        } catch (e) {
            // don't die if something goes wrong
        }
@@ -1641,6 +1720,80 @@ MegolmDecryption.prototype.retryDecryptionFromSender = async function(senderKey)
    return !this._pendingEvents[senderKey];
 };

+MegolmDecryption.prototype.sendSharedHistoryInboundSessions = async function(devicesByUser) {
+    await olmlib.ensureOlmSessionsForDevices(
+        this._olmDevice, this._baseApis, devicesByUser,
+    );
+
+    logger.log("sendSharedHistoryInboundSessions to users", Object.keys(devicesByUser));
+
+    const sharedHistorySessions =
+          await this._olmDevice.getSharedHistoryInboundGroupSessions(
+              this._roomId,
+          );
+    logger.log("shared-history sessions", sharedHistorySessions);
+    for (const [senderKey, sessionId] of sharedHistorySessions) {
+        const payload = await this._buildKeyForwardingMessage(
+            this._roomId, senderKey, sessionId,
+        );
+
+        const promises = [];
+        const contentMap = {};
+        for (const [userId, devices] of Object.entries(devicesByUser)) {
+            contentMap[userId] = {};
+            for (const deviceInfo of devices) {
+                const encryptedContent = {
+                    algorithm: olmlib.OLM_ALGORITHM,
+                    sender_key: this._olmDevice.deviceCurve25519Key,
+                    ciphertext: {},
+                };
+                contentMap[userId][deviceInfo.deviceId] = encryptedContent;
+                promises.push(
+                    olmlib.encryptMessageForDevice(
+                        encryptedContent.ciphertext,
+                        this._userId,
+                        this._deviceId,
+                        this._olmDevice,
+                        userId,
+                        deviceInfo,
+                        payload,
+                    ),
+                );
+            }
+        }
+        await Promise.all(promises);
+
+        // prune out any devices that encryptMessageForDevice could not encrypt for,
+        // in which case it will have just not added anything to the ciphertext object.
+        // There's no point sending messages to devices if we couldn't encrypt to them,
+        // since that's effectively a blank message.
+        for (const userId of Object.keys(contentMap)) {
+            for (const deviceId of Object.keys(contentMap[userId])) {
+                if (Object.keys(contentMap[userId][deviceId].ciphertext).length === 0) {
+                    logger.log(
+                        "No ciphertext for device " +
+                            userId + ":" + deviceId + ": pruning",
+                    );
+                    delete contentMap[userId][deviceId];
+                }
+            }
+            // No devices left for that user? Strip that too.
+            if (Object.keys(contentMap[userId]).length === 0) {
+                logger.log("Pruned all devices for user " + userId);
+                delete contentMap[userId];
+            }
+        }
+
+        // Is there anything left?
+        if (Object.keys(contentMap).length === 0) {
+            logger.log("No users left to send to: aborting");
+            return;
+        }
+
+        await this._baseApis.sendToDevice("m.room.encrypted", contentMap);
+    }
+};
+
 registerAlgorithm(
    olmlib.MEGOLM_ALGORITHM, MegolmEncryption, MegolmDecryption,
 );
@@ -20,11 +20,11 @@ limitations under the License.
 * @module crypto/algorithms/olm
 */

-import {logger} from '../../logger';
+import { logger } from '../../logger';
 import * as utils from "../../utils";
-import {polyfillSuper} from "../../utils";
+import { polyfillSuper } from "../../utils";
 import * as olmlib from "../olmlib";
-import {DeviceInfo} from "../deviceinfo";
+import { DeviceInfo } from "../deviceinfo";
 import {
    DecryptionAlgorithm,
    DecryptionError,
@@ -95,7 +95,7 @@ OlmEncryption.prototype.encryptMessage = async function(room, eventType, content

    const members = await room.getEncryptionTargetMembers();

-    const users = utils.map(members, function(u) {
+    const users = members.map(function(u) {
        return u.userId;
    });

@@ -358,5 +358,4 @@ OlmDecryption.prototype._reallyDecryptMessage = async function(
    return res.payload;
 };

-
 registerAlgorithm(olmlib.OLM_ALGORITHM, OlmEncryption, OlmDecryption);
@@ -14,11 +14,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {decodeBase64, encodeBase64} from './olmlib';
-import {IndexedDBCryptoStore} from '../crypto/store/indexeddb-crypto-store';
-import {decryptAES, encryptAES} from './aes';
+import { decodeBase64, encodeBase64 } from './olmlib';
+import { IndexedDBCryptoStore } from '../crypto/store/indexeddb-crypto-store';
+import { decryptAES, encryptAES } from './aes';
 import anotherjson from "another-json";
-import {logger} from '../logger';
+import { logger } from '../logger';

 // FIXME: these types should eventually go in a different file
 type Signatures = Record<string, Record<string, string>>;
@@ -51,7 +51,7 @@ export class DehydrationManager {
        this.getDehydrationKeyFromCache();
    }
    async getDehydrationKeyFromCache(): Promise<void> {
-        return this.crypto._cryptoStore.doTxn(
+        return await this.crypto._cryptoStore.doTxn(
            'readonly',
            [IndexedDBCryptoStore.STORE_ACCOUNT],
            (txn) => {
@@ -59,7 +59,7 @@ export class DehydrationManager {
                    txn,
                    async (result) => {
                        if (result) {
-                            const {key, keyInfo, deviceDisplayName, time} = result;
+                            const { key, keyInfo, deviceDisplayName, time } = result;
                            const pickleKey = Buffer.from(this.crypto._olmDevice._pickleKey);
                            const decrypted = await decryptAES(key, pickleKey, DEHYDRATION_ALGORITHM);
                            this.key = decodeBase64(decrypted);
@@ -77,10 +77,23 @@ export class DehydrationManager {
            },
        );
    }
-    async setDehydrationKey(
+
+    /** set the key, and queue periodic dehydration to the server in the background */
+    async setKeyAndQueueDehydration(
        key: Uint8Array, keyInfo: {[props: string]: any} = {},
        deviceDisplayName: string = undefined,
    ): Promise<void> {
+        const matches = await this.setKey(key, keyInfo, deviceDisplayName);
+        if (!matches) {
+            // start dehydration in the background
+            this.dehydrateDevice();
+        }
+    }
+
+    async setKey(
+        key: Uint8Array, keyInfo: {[props: string]: any} = {},
+        deviceDisplayName: string = undefined,
+    ): Promise<boolean> {
        if (!key) {
            // unsetting the key -- cancel any pending dehydration task
            if (this.timeoutId) {
@@ -88,7 +101,7 @@ export class DehydrationManager {
                this.timeoutId = undefined;
            }
            // clear storage
-            this.crypto._cryptoStore.doTxn(
+            await this.crypto._cryptoStore.doTxn(
                'readwrite',
                [IndexedDBCryptoStore.STORE_ACCOUNT],
                (txn) => {
@@ -104,7 +117,7 @@ export class DehydrationManager {

        // Check to see if it's the same key as before.  If it's different,
        // dehydrate a new device.  If it's the same, we can keep the same
-        // device.  (Assume that keyInfo and deviceDisplayNamme will be the
+        // device.  (Assume that keyInfo and deviceDisplayName will be the
        // same if the key is the same.)
        let matches: boolean = this.key && key.length == this.key.length;
        for (let i = 0; matches && i < key.length; i++) {
@@ -116,11 +129,12 @@ export class DehydrationManager {
            this.key = key;
            this.keyInfo = keyInfo;
            this.deviceDisplayName = deviceDisplayName;
-            // start dehydration in the background
-            this.dehydrateDevice();
        }
+        return matches;
    }
-    private async dehydrateDevice(): Promise<void> {
+
+    /** returns the device id of the newly created dehydrated device */
+    async dehydrateDevice(): Promise<string> {
        if (this.inProgress) {
            logger.log("Dehydration already in progress -- not starting new dehydration");
            return;
@@ -135,7 +149,7 @@ export class DehydrationManager {

            // update the crypto store with the timestamp
            const key = await encryptAES(encodeBase64(this.key), pickleKey, DEHYDRATION_ALGORITHM);
-            this.crypto._cryptoStore.doTxn(
+            await this.crypto._cryptoStore.doTxn(
                'readwrite',
                [IndexedDBCryptoStore.STORE_ACCOUNT],
                (txn) => {
@@ -217,7 +231,7 @@ export class DehydrationManager {
            logger.log("Preparing one-time keys");
            const oneTimeKeys = {};
            for (const [keyId, key] of Object.entries(otks.curve25519)) {
-                const k: OneTimeKey = {key};
+                const k: OneTimeKey = { key };
                const signature = account.sign(anotherjson.stringify(k));
                k.signatures = {
                    [this.crypto._userId]: {
@@ -230,7 +244,7 @@ export class DehydrationManager {
            logger.log("Preparing fallback keys");
            const fallbackKeys = {};
            for (const [keyId, key] of Object.entries(fallbacks.curve25519)) {
-                const k: OneTimeKey = {key, fallback: true};
+                const k: OneTimeKey = { key, fallback: true };
                const signature = account.sign(anotherjson.stringify(k));
                k.signatures = {
                    [this.crypto._userId]: {
@@ -258,8 +272,17 @@ export class DehydrationManager {
            this.timeoutId = global.setTimeout(
                this.dehydrateDevice.bind(this), oneweek,
            );
+
+            return deviceId;
        } finally {
            this.inProgress = false;
        }
    }
+
+    private stop() {
+        if (this.timeoutId) {
+            global.clearTimeout(this.timeoutId);
+            this.timeoutId = undefined;
+        }
+    }
 }
@@ -22,15 +22,15 @@ limitations under the License.
 */

 import anotherjson from "another-json";
-import {EventEmitter} from 'events';
-import {ReEmitter} from '../ReEmitter';
-import {logger} from '../logger';
+import { EventEmitter } from 'events';
+import { ReEmitter } from '../ReEmitter';
+import { logger } from '../logger';
 import * as utils from "../utils";
-import {sleep} from "../utils";
-import {OlmDevice} from "./OlmDevice";
+import { sleep } from "../utils";
+import { OlmDevice } from "./OlmDevice";
 import * as olmlib from "./olmlib";
-import {DeviceList} from "./DeviceList";
-import {DeviceInfo} from "./deviceinfo";
+import { DeviceList } from "./DeviceList";
+import { DeviceInfo } from "./deviceinfo";
 import * as algorithms from "./algorithms";
 import {
    CrossSigningInfo,
@@ -38,25 +38,26 @@ import {
    UserTrustLevel,
    createCryptoStoreCacheCallbacks,
 } from './CrossSigning';
-import {EncryptionSetupBuilder} from "./EncryptionSetup";
-import {SECRET_STORAGE_ALGORITHM_V1_AES, SecretStorage} from './SecretStorage';
-import {OutgoingRoomKeyRequestManager} from './OutgoingRoomKeyRequestManager';
-import {IndexedDBCryptoStore} from './store/indexeddb-crypto-store';
+import { EncryptionSetupBuilder } from "./EncryptionSetup";
+import { SECRET_STORAGE_ALGORITHM_V1_AES, SecretStorage } from './SecretStorage';
+import { OutgoingRoomKeyRequestManager } from './OutgoingRoomKeyRequestManager';
+import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
 import {
    ReciprocateQRCode,
    SCAN_QR_CODE_METHOD,
    SHOW_QR_CODE_METHOD,
 } from './verification/QRCode';
-import {SAS} from './verification/SAS';
-import {keyFromPassphrase} from './key_passphrase';
-import {encodeRecoveryKey, decodeRecoveryKey} from './recoverykey';
-import {VerificationRequest} from "./verification/request/VerificationRequest";
-import {InRoomChannel, InRoomRequests} from "./verification/request/InRoomChannel";
-import {ToDeviceChannel, ToDeviceRequests} from "./verification/request/ToDeviceChannel";
-import {IllegalMethod} from "./verification/IllegalMethod";
-import {KeySignatureUploadError} from "../errors";
-import {decryptAES, encryptAES} from './aes';
-import {DehydrationManager} from './dehydration';
+import { SAS } from './verification/SAS';
+import { keyFromPassphrase } from './key_passphrase';
+import { encodeRecoveryKey, decodeRecoveryKey } from './recoverykey';
+import { VerificationRequest } from "./verification/request/VerificationRequest";
+import { InRoomChannel, InRoomRequests } from "./verification/request/InRoomChannel";
+import { ToDeviceChannel, ToDeviceRequests } from "./verification/request/ToDeviceChannel";
+import { IllegalMethod } from "./verification/IllegalMethod";
+import { KeySignatureUploadError } from "../errors";
+import { decryptAES, encryptAES } from './aes';
+import { DehydrationManager } from './dehydration';
+import { MatrixEvent } from "../models/event";

 const DeviceVerification = DeviceInfo.DeviceVerification;

@@ -185,7 +186,7 @@ export function Crypto(baseApis, sessionStore, userId, deviceId,
    // map from algorithm to DecryptionAlgorithm instance, for each room
    this._roomDecryptors = {};

-    this._supportedAlgorithms = utils.keys(
+    this._supportedAlgorithms = Object.keys(
        algorithms.DECRYPTION_CLASSES,
    );

@@ -567,7 +568,9 @@ Crypto.prototype.bootstrapCrossSigning = async function({
            "Cross-signing private keys not found locally, but they are available " +
            "in secret storage, reading storage and caching locally",
        );
-        await this.checkOwnCrossSigningTrust();
+        await this.checkOwnCrossSigningTrust({
+            allowPrivateKeyRequests: true,
+        });
    }

    // Assuming no app-supplied callback, default to storing new private keys in
@@ -633,7 +636,7 @@ Crypto.prototype.bootstrapCrossSigning = async function({
 *     containing the key, or rejects if the key cannot be obtained.
 * Returns:
 *     {Promise} A promise which resolves to key creation data for
- *     SecretStorage#addKey: an object with `passphrase` and/or `pubkey` fields.
+ *     SecretStorage#addKey: an object with `passphrase` etc fields.
 */
 Crypto.prototype.bootstrapSecretStorage = async function({
    createSecretStorageKey = async () => ({ }),
@@ -663,13 +666,13 @@ Crypto.prototype.bootstrapSecretStorage = async function({
            opts.key = privateKey;
        }

-        const keyId = await secretStorage.addKey(
+        const { keyId, keyInfo } = await secretStorage.addKey(
            SECRET_STORAGE_ALGORITHM_V1_AES, opts,
        );

        if (privateKey) {
            // make the private key available to encrypt 4S secrets
-            builder.ssssCryptoCallbacks.addPrivateKey(keyId, privateKey);
+            builder.ssssCryptoCallbacks.addPrivateKey(keyId, keyInfo, privateKey);
        }

        await secretStorage.setDefaultKeyId(keyId);
@@ -679,12 +682,12 @@ Crypto.prototype.bootstrapSecretStorage = async function({
    const ensureCanCheckPassphrase = async (keyId, keyInfo) => {
        if (!keyInfo.mac) {
            const key = await this._baseApis._cryptoCallbacks.getSecretStorageKey(
-                {keys: {[keyId]: keyInfo}}, "",
+                { keys: { [keyId]: keyInfo } }, "",
            );
            if (key) {
-                const keyData = key[1];
-                builder.ssssCryptoCallbacks.addPrivateKey(keyId, keyData);
-                const {iv, mac} = await SecretStorage._calculateKeyCheck(keyData);
+                const privateKey = key[1];
+                builder.ssssCryptoCallbacks.addPrivateKey(keyId, keyInfo, privateKey);
+                const { iv, mac } = await SecretStorage._calculateKeyCheck(privateKey);
                keyInfo.iv = iv;
                keyInfo.mac = mac;

@@ -695,6 +698,26 @@ Crypto.prototype.bootstrapSecretStorage = async function({
        }
    };

+    const signKeyBackupWithCrossSigning = async (keyBackupAuthData) => {
+        if (
+            this._crossSigningInfo.getId() &&
+            await this._crossSigningInfo.isStoredInKeyCache("master")
+        ) {
+            try {
+                logger.log("Adding cross-signing signature to key backup");
+                await this._crossSigningInfo.signObject(keyBackupAuthData, "master");
+            } catch (e) {
+                // This step is not critical (just helpful), so we catch here
+                // and continue if it fails.
+                logger.error("Signing key backup with cross-signing keys failed", e);
+            }
+        } else {
+            logger.warn(
+                "Cross-signing keys not available, skipping signature on key backup",
+            );
+        }
+    };
+
    const oldSSSSKey = await this.getSecretStorageKey();
    const [oldKeyId, oldKeyInfo] = oldSSSSKey || [null, null];
    const storageExists = (
@@ -761,19 +784,7 @@ Crypto.prototype.bootstrapSecretStorage = async function({
        // The backup is trusted because the user provided the private key.
        // Sign the backup with the cross-signing key so the key backup can
        // be trusted via cross-signing.
-        if (
-            this._crossSigningInfo.getId() &&
-            this._crossSigningInfo.isStoredInKeyCache("master")
-        ) {
-            logger.log("Adding cross-signing signature to key backup");
-            await this._crossSigningInfo.signObject(
-                keyBackupInfo.auth_data, "master",
-            );
-        } else {
-            logger.warn(
-                "Cross-signing keys not available, skipping signature on key backup",
-            );
-        }
+        await signKeyBackupWithCrossSigning(keyBackupInfo.auth_data);

        builder.addSessionBackup(keyBackupInfo);
    } else {
@@ -824,18 +835,8 @@ Crypto.prototype.bootstrapSecretStorage = async function({
            auth_data: info.auth_data,
        };

-        if (
-            this._crossSigningInfo.getId() &&
-            this._crossSigningInfo.isStoredInKeyCache("master")
-        ) {
-            // sign with cross-sign master key
-            logger.log("Adding cross-signing signature to key backup");
-            await this._crossSigningInfo.signObject(data.auth_data, "master");
-        } else {
-            logger.warn(
-                "Cross-signing keys not available, skipping signature on key backup",
-            );
-        }
+        // Sign with cross-signing master key
+        await signKeyBackupWithCrossSigning(data.auth_data);

        // sign with the device fingerprint
        await this._signObject(data.auth_data);
@@ -1301,13 +1302,19 @@ Crypto.prototype._onDeviceListUserCrossSigningUpdated = async function(userId) {
 * Check the copy of our cross-signing key that we have in the device list and
 * see if we can get the private key. If so, mark it as trusted.
 */
-Crypto.prototype.checkOwnCrossSigningTrust = async function() {
+Crypto.prototype.checkOwnCrossSigningTrust = async function({
+    allowPrivateKeyRequests = false,
+} = {}) {
    const userId = this._userId;

    // Before proceeding, ensure our cross-signing public keys have been
    // downloaded via the device list.
    await this.downloadKeys([this._userId]);

+    // Also check which private keys are locally cached.
+    const crossSigningPrivateKeys =
+        await this._crossSigningInfo.getCrossSigningKeysFromCache();
+
    // If we see an update to our own master key, check it against the master
    // key we have and, if it matches, mark it as verified

@@ -1323,18 +1330,26 @@ Crypto.prototype.checkOwnCrossSigningTrust = async function() {

    const seenPubkey = newCrossSigning.getId();
    const masterChanged = this._crossSigningInfo.getId() !== seenPubkey;
+    const masterExistsNotLocallyCached =
+        newCrossSigning.getId() && !crossSigningPrivateKeys.has("master");
    if (masterChanged) {
        logger.info("Got new master public key", seenPubkey);
+    }
+    if (
+        allowPrivateKeyRequests &&
+        (masterChanged || masterExistsNotLocallyCached)
+    ) {
        logger.info("Attempting to retrieve cross-signing master private key");
        let signing = null;
+        // It's important for control flow that we leave any errors alone for
+        // higher levels to handle so that e.g. cancelling access properly
+        // aborts any larger operation as well.
        try {
            const ret = await this._crossSigningInfo.getCrossSigningKey(
                'master', seenPubkey,
            );
            signing = ret[1];
            logger.info("Got cross-signing master private key");
-        } catch (e) {
-            logger.error("Cross-signing master private key not available", e);
        } finally {
            if (signing) signing.free();
        }
@@ -1349,10 +1364,24 @@ Crypto.prototype.checkOwnCrossSigningTrust = async function() {
    const selfSigningChanged = oldSelfSigningId !== newCrossSigning.getId("self_signing");
    const userSigningChanged = oldUserSigningId !== newCrossSigning.getId("user_signing");

+    const selfSigningExistsNotLocallyCached = (
+        newCrossSigning.getId("self_signing") &&
+        !crossSigningPrivateKeys.has("self_signing")
+    );
+    const userSigningExistsNotLocallyCached = (
+        newCrossSigning.getId("user_signing") &&
+        !crossSigningPrivateKeys.has("user_signing")
+    );
+
    const keySignatures = {};

    if (selfSigningChanged) {
        logger.info("Got new self-signing key", newCrossSigning.getId("self_signing"));
+    }
+    if (
+        allowPrivateKeyRequests &&
+        (selfSigningChanged || selfSigningExistsNotLocallyCached)
+    ) {
        logger.info("Attempting to retrieve cross-signing self-signing private key");
        let signing = null;
        try {
@@ -1361,8 +1390,6 @@ Crypto.prototype.checkOwnCrossSigningTrust = async function() {
            );
            signing = ret[1];
            logger.info("Got cross-signing self-signing private key");
-        } catch (e) {
-            logger.error("Cross-signing self-signing private key not available", e);
        } finally {
            if (signing) signing.free();
        }
@@ -1375,6 +1402,11 @@ Crypto.prototype.checkOwnCrossSigningTrust = async function() {
    }
    if (userSigningChanged) {
        logger.info("Got new user-signing key", newCrossSigning.getId("user_signing"));
+    }
+    if (
+        allowPrivateKeyRequests &&
+        (userSigningChanged || userSigningExistsNotLocallyCached)
+    ) {
        logger.info("Attempting to retrieve cross-signing user-signing private key");
        let signing = null;
        try {
@@ -1383,8 +1415,6 @@ Crypto.prototype.checkOwnCrossSigningTrust = async function() {
            );
            signing = ret[1];
            logger.info("Got cross-signing user-signing private key");
-        } catch (e) {
-            logger.error("Cross-signing user-signing private key not available", e);
        } finally {
            if (signing) signing.free();
        }
@@ -1569,7 +1599,7 @@ Crypto.prototype._checkAndStartKeyBackup = async function() {
        }
    }

-    return {backupInfo, trustInfo};
+    return { backupInfo, trustInfo };
 };

 Crypto.prototype.setTrustedBackupPubKey = async function(trustedPubKey) {
@@ -1744,7 +1774,6 @@ Crypto.prototype.registerEventHandlers = function(eventEmitter) {
    eventEmitter.on("Event.decrypted", timelineHandler);
 };

-
 /** Start background processes related to crypto */
 Crypto.prototype.start = function() {
    this._outgoingRoomKeyRequestManager.start();
@@ -1754,6 +1783,7 @@ Crypto.prototype.start = function() {
 Crypto.prototype.stop = function() {
    this._outgoingRoomKeyRequestManager.stop();
    this._deviceList.stop();
+    this._dehydrationManager.stop();
 };

 /**
@@ -2200,7 +2230,7 @@ Crypto.prototype.setDeviceVerification = async function(
        }

        if (device) {
-            const upload = async ({shouldEmit}) => {
+            const upload = async ({ shouldEmit }) => {
                logger.info("Uploading signature for " + deviceId);
                const response = await this._baseApis.uploadKeySignatures({
                    [userId]: {
@@ -2220,7 +2250,7 @@ Crypto.prototype.setDeviceVerification = async function(
                    throw new KeySignatureUploadError("Key upload failed", { failures });
                }
            };
-            await upload({shouldEmit: true});
+            await upload({ shouldEmit: true });
            // XXX: we'll need to wait for the device list to be updated
        }
    }
@@ -2313,7 +2343,7 @@ Crypto.prototype.beginKeyVerification = function(
        this._toDeviceVerificationRequests.setRequestBySenderAndTxnId(
            userId, transactionId, request);
    }
-    return request.beginKeyVerification(method, {userId, deviceId});
+    return request.beginKeyVerification(method, { userId, deviceId });
 };

 Crypto.prototype.legacyDeviceVerification = async function(
@@ -2326,7 +2356,7 @@ Crypto.prototype.legacyDeviceVerification = async function(
        channel, this._verificationMethods, this._baseApis);
    this._toDeviceVerificationRequests.setRequestBySenderAndTxnId(
        userId, transactionId, request);
-    const verifier = request.beginKeyVerification(method, {userId, deviceId});
+    const verifier = request.beginKeyVerification(method, { userId, deviceId });
    // either reject by an error from verify() while sending .start
    // or resolve when the request receives the
    // local (fake remote) echo for sending the .start event
@@ -2337,7 +2367,6 @@ Crypto.prototype.legacyDeviceVerification = async function(
    return request;
 };

-
 /**
 * Get information on the active olm sessions with a user
 * <p>
@@ -2368,7 +2397,6 @@ Crypto.prototype.getOlmSessionsForUser = async function(userId) {
    return result;
 };

-
 /**
 * Get the device which sent an event
 *
@@ -2613,7 +2641,6 @@ Crypto.prototype.setRoomEncryption = async function(roomId, config, inhibitDevic
    }
 };

-
 /**
 * Make sure we are tracking the device lists for all users in this room.
 *
@@ -2640,7 +2667,10 @@ Crypto.prototype.trackRoomDevices = function(roomId) {
    let promise = this._roomDeviceTrackingState[roomId];
    if (!promise) {
        promise = trackMembers();
-        this._roomDeviceTrackingState[roomId] = promise;
+        this._roomDeviceTrackingState[roomId] = promise.catch(err => {
+            this._roomDeviceTrackingState[roomId] = null;
+            throw err;
+        });
    }
    return promise;
 };
@@ -2833,7 +2863,7 @@ Crypto.prototype._backupPendingKeys = async function(limit) {
    for (const session of sessions) {
        const roomId = session.sessionData.room_id;
        if (data[roomId] === undefined) {
-            data[roomId] = {sessions: {}};
+            data[roomId] = { sessions: {} };
        }

        const sessionData = await this._olmDevice.exportInboundGroupSession(
@@ -2867,7 +2897,7 @@ Crypto.prototype._backupPendingKeys = async function(limit) {

    await this._baseApis.sendKeyBackup(
        undefined, undefined, this.backupInfo.version,
-        {rooms: data},
+        { rooms: data },
    );

    await this._cryptoStore.unmarkSessionsNeedingBackup(sessions);
@@ -2882,18 +2912,18 @@ Crypto.prototype.backupGroupSession = async function(
    sessionId, sessionKey, keysClaimed,
    exportFormat,
 ) {
-    if (!this.backupInfo) {
-        throw new Error("Key backups are not enabled");
-    }
-
    await this._cryptoStore.markSessionsNeedingBackup([{
        senderKey: senderKey,
        sessionId: sessionId,
    }]);

-    // don't wait for this to complete: it will delay so
-    // happens in the background
-    this.scheduleKeyBackupSend();
+    if (this.backupInfo) {
+        // don't wait for this to complete: it will delay so
+        // happens in the background
+        this.scheduleKeyBackupSend();
+    }
+    // if this.backupInfo is not set, then the keys will be backed up when
+    // client.enableKeyBackup is called
 };

 /**
@@ -3026,19 +3056,26 @@ Crypto.prototype.encryptEvent = async function(event, room) {
 *  finished decrypting. Rejects with an `algorithms.DecryptionError` if there
 *  is a problem decrypting the event.
 */
-Crypto.prototype.decryptEvent = function(event) {
+Crypto.prototype.decryptEvent = async function(event) {
    if (event.isRedacted()) {
-        return Promise.resolve({
+        const redactionEvent = new MatrixEvent(event.getUnsigned().redacted_because);
+        const decryptedEvent = await this.decryptEvent(redactionEvent);
+
+        return {
            clearEvent: {
                room_id: event.getRoomId(),
                type: "m.room.message",
                content: {},
+                unsigned: {
+                    redacted_because: decryptedEvent.clearEvent,
+                },
            },
-        });
+        };
+    } else {
+        const content = event.getWireContent();
+        const alg = this._getRoomDecryptor(event.getRoomId(), content.algorithm);
+        return await alg.decryptEvent(event);
    }
-    const content = event.getWireContent();
-    const alg = this._getRoomDecryptor(event.getRoomId(), content.algorithm);
-    return alg.decryptEvent(event);
 };

 /**
@@ -3260,7 +3297,6 @@ Crypto.prototype._getTrackedE2eRooms = function() {
    });
 };

-
 Crypto.prototype._onToDeviceEvent = function(event) {
    try {
        logger.log(`received to_device ${event.getType()} from: ` +
@@ -3281,7 +3317,10 @@ Crypto.prototype._onToDeviceEvent = function(event) {
            this._onKeyVerificationMessage(event);
        } else if (event.getContent().msgtype === "m.bad.encrypted") {
            this._onToDeviceBadEncrypted(event);
-        } else if (event.isBeingDecrypted()) {
+        } else if (event.isBeingDecrypted() || event.shouldAttemptDecryption()) {
+            if (!event.isBeingDecrypted()) {
+                event.attemptDecryption(this);
+            }
            // once the event has been decrypted, try again
            event.once('Event.decrypted', (ev) => {
                this._onToDeviceEvent(ev);
@@ -3398,7 +3437,7 @@ Crypto.prototype._onKeyVerificationMessage = function(event) {
 * @param {bool} data.liveEvent whether this is a live event
 */
 Crypto.prototype._onTimelineEvent = function(
-    event, room, atStart, removed, {liveEvent} = {},
+    event, room, atStart, removed, { liveEvent } = {},
 ) {
    if (!InRoomChannel.validateEvent(event, this._baseApis)) {
        return;
@@ -3536,7 +3575,7 @@ Crypto.prototype._onToDeviceBadEncrypted = async function(event) {
        this._olmDevice,
        sender,
        device,
-        {type: "m.dummy"},
+        { type: "m.dummy" },
    );

    await this._olmDevice.recordSessionProblem(deviceKey, "wedged", true);
@@ -3548,7 +3587,6 @@ Crypto.prototype._onToDeviceBadEncrypted = async function(event) {
        },
    });

-
    // Most of the time this probably won't be necessary since we'll have queued up a key request when
    // we failed to decrypt the message and will be waiting a bit for the key to arrive before sending
    // it. This won't always be the case though so we need to re-send any that have already been sent
@@ -3605,7 +3643,6 @@ Crypto.prototype._onRoomMembership = function(event, member, oldMembership) {
    alg.onRoomMembership(event, member, oldMembership);
 };

-
 /**
 * Called when we get an m.room_key_request event.
 *
@@ -3758,7 +3795,6 @@ Crypto.prototype._processReceivedRoomKeyRequest = async function(req) {
    this.emit("crypto.roomKeyRequest", req);
 };

-
 /**
 * Helper for processReceivedRoomKeyRequests
 *
@@ -3834,7 +3870,6 @@ Crypto.prototype._getRoomDecryptor = function(roomId, algorithm) {
    return alg;
 };

-
 /**
 * Get all the room decryptors for a given encryption algorithm.
 *
@@ -3852,7 +3887,6 @@ Crypto.prototype._getRoomDecryptors = function(algorithm) {
    return decryptors;
 };

-
 /**
 * sign the given object with our ed25519 key
 *
@@ -3872,7 +3906,6 @@ Crypto.prototype._signObject = async function(obj) {
    if (unsigned !== undefined) obj.unsigned = unsigned;
 };

-
 /**
 * The parameters of a room key request. The details of the request may
 * vary with the crypto algorithm, but the management and storage layers for
@@ -15,7 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {randomString} from '../randomstring';
+import { randomString } from '../randomstring';

 const DEFAULT_ITERATIONS = 500000;

@@ -63,7 +63,7 @@ export async function deriveKey(password, salt, iterations, numBits = DEFAULT_BI
    const key = await subtleCrypto.importKey(
        'raw',
        new TextEncoder().encode(password),
-        {name: 'PBKDF2'},
+        { name: 'PBKDF2' },
        false,
        ['deriveBits'],
    );
@@ -22,7 +22,7 @@ limitations under the License.
 * Utilities common to olm encryption algorithms
 */

-import {logger} from '../logger';
+import { logger } from '../logger';
 import * as utils from "../utils";
 import anotherjson from "another-json";

@@ -41,7 +41,6 @@ export const MEGOLM_ALGORITHM = "m.megolm.v1.aes-sha2";
 */
 export const MEGOLM_BACKUP_ALGORITHM = "m.megolm_backup.v1.curve25519-aes-sha2";

-
 /**
 * Encrypt an event payload for an Olm device
 *
@@ -183,18 +182,24 @@ export async function getExistingOlmSessions(
 * @param {Array} [failedServers] An array to fill with remote servers that
 *     failed to respond to one-time-key requests.
 *
+ * @param {Logger} [log] A possibly customised log
+ *
 * @return {Promise} resolves once the sessions are complete, to
 *    an Object mapping from userId to deviceId to
 *    {@link module:crypto~OlmSessionResult}
 */
 export async function ensureOlmSessionsForDevices(
-    olmDevice, baseApis, devicesByUser, force, otkTimeout, failedServers,
+    olmDevice, baseApis, devicesByUser, force, otkTimeout, failedServers, log,
 ) {
    if (typeof force === "number") {
+        log = failedServers;
        failedServers = otkTimeout;
        otkTimeout = force;
        force = false;
    }
+    if (!log) {
+        log = logger;
+    }

    const devicesWithoutSession = [
        // [userId, deviceId], ...
@@ -202,6 +207,35 @@ export async function ensureOlmSessionsForDevices(
    const result = {};
    const resolveSession = {};

+    // Mark all sessions this task intends to update as in progress. It is
+    // important to do this for all devices this task cares about in a single
+    // synchronous operation, as otherwise it is possible to have deadlocks
+    // where multiple tasks wait indefinitely on another task to update some set
+    // of common devices.
+    for (const [, devices] of Object.entries(devicesByUser)) {
+        for (const deviceInfo of devices) {
+            const key = deviceInfo.getIdentityKey();
+
+            if (key === olmDevice.deviceCurve25519Key) {
+                // We don't start sessions with ourself, so there's no need to
+                // mark it in progress.
+                continue;
+            }
+
+            if (!olmDevice._sessionsInProgress[key]) {
+                // pre-emptively mark the session as in-progress to avoid race
+                // conditions.  If we find that we already have a session, then
+                // we'll resolve
+                olmDevice._sessionsInProgress[key] = new Promise(resolve => {
+                    resolveSession[key] = (...args) => {
+                        delete olmDevice._sessionsInProgress[key];
+                        resolve(...args);
+                    };
+                });
+            }
+        }
+    }
+
    for (const [userId, devices] of Object.entries(devicesByUser)) {
        result[userId] = {};
        for (const deviceInfo of devices) {
@@ -216,7 +250,7 @@ export async function ensureOlmSessionsForDevices(
                // new chain when this side has an active sender chain.
                // If you see this message being logged in the wild, we should find
                // the thing that is trying to send Olm messages to itself and fix it.
-                logger.info("Attempted to start session with ourself! Ignoring");
+                log.info("Attempted to start session with ourself! Ignoring");
                // We must fill in the section in the return value though, as callers
                // expect it to be there.
                result[userId][deviceId] = {
@@ -226,41 +260,21 @@ export async function ensureOlmSessionsForDevices(
                continue;
            }

-            if (!olmDevice._sessionsInProgress[key]) {
-                // pre-emptively mark the session as in-progress to avoid race
-                // conditions.  If we find that we already have a session, then
-                // we'll resolve
-                olmDevice._sessionsInProgress[key] = new Promise(
-                    (resolve, reject) => {
-                        resolveSession[key] = {
-                            resolve: (...args) => {
-                                delete olmDevice._sessionsInProgress[key];
-                                resolve(...args);
-                            },
-                            reject: (...args) => {
-                                delete olmDevice._sessionsInProgress[key];
-                                reject(...args);
-                            },
-                        };
-                    },
-                );
-            }
+            const forWhom = `for ${key} (${userId}:${deviceId})`;
            const sessionId = await olmDevice.getSessionIdForDevice(
-                key, resolveSession[key],
+                key, resolveSession[key], log,
            );
            if (sessionId !== null && resolveSession[key]) {
                // we found a session, but we had marked the session as
-                // in-progress, so unmark it and unblock anything that was
-                // waiting
-                delete olmDevice._sessionsInProgress[key];
-                resolveSession[key].resolve();
-                delete resolveSession[key];
+                // in-progress, so resolve it now, which will unmark it and
+                // unblock anything that was waiting
+                resolveSession[key]();
            }
            if (sessionId === null || force) {
                if (force) {
-                    logger.info("Forcing new Olm session for " + userId + ":" + deviceId);
+                    log.info(`Forcing new Olm session ${forWhom}`);
                } else {
-                    logger.info("Making new Olm session for " + userId + ":" + deviceId);
+                    log.info(`Making new Olm session ${forWhom}`);
                }
                devicesWithoutSession.push([userId, deviceId]);
            }
@@ -277,15 +291,18 @@ export async function ensureOlmSessionsForDevices(

    const oneTimeKeyAlgorithm = "signed_curve25519";
    let res;
+    let taskDetail = `one-time keys for ${devicesWithoutSession.length} devices`;
    try {
+        log.debug(`Claiming ${taskDetail}`);
        res = await baseApis.claimOneTimeKeys(
            devicesWithoutSession, oneTimeKeyAlgorithm, otkTimeout,
        );
+        log.debug(`Claimed ${taskDetail}`);
    } catch (e) {
        for (const resolver of Object.values(resolveSession)) {
-            resolver.resolve();
+            resolver();
        }
-        logger.log("failed to claim one-time keys", e, devicesWithoutSession);
+        log.log(`Failed to claim ${taskDetail}`, e, devicesWithoutSession);
        throw e;
    }

@@ -293,10 +310,10 @@ export async function ensureOlmSessionsForDevices(
        failedServers.push(...Object.keys(res.failures));
    }

-    const otk_res = res.one_time_keys || {};
+    const otkResult = res.one_time_keys || {};
    const promises = [];
    for (const [userId, devices] of Object.entries(devicesByUser)) {
-        const userRes = otk_res[userId] || {};
+        const userRes = otkResult[userId] || {};
        for (let j = 0; j < devices.length; j++) {
            const deviceInfo = devices[j];
            const deviceId = deviceInfo.deviceId;
@@ -323,11 +340,12 @@ export async function ensureOlmSessionsForDevices(
            }

            if (!oneTimeKey) {
-                const msg = "No one-time keys (alg=" + oneTimeKeyAlgorithm +
-                      ") for device " + userId + ":" + deviceId;
-                logger.warn(msg);
+                log.warn(
+                    `No one-time keys (alg=${oneTimeKeyAlgorithm}) ` +
+                    `for device ${userId}:${deviceId}`,
+                );
                if (resolveSession[key]) {
-                    resolveSession[key].resolve();
+                    resolveSession[key]();
                }
                continue;
            }
@@ -337,12 +355,12 @@ export async function ensureOlmSessionsForDevices(
                    olmDevice, oneTimeKey, userId, deviceInfo,
                ).then((sid) => {
                    if (resolveSession[key]) {
-                        resolveSession[key].resolve(sid);
+                        resolveSession[key](sid);
                    }
                    result[userId][deviceId].sessionId = sid;
                }, (e) => {
                    if (resolveSession[key]) {
-                        resolveSession[key].resolve();
+                        resolveSession[key]();
                    }
                    throw e;
                }),
@@ -350,7 +368,10 @@ export async function ensureOlmSessionsForDevices(
        }
    }

+    taskDetail = `Olm sessions for ${promises.length} devices`;
+    log.debug(`Starting ${taskDetail}`);
    await Promise.all(promises);
+    log.debug(`Started ${taskDetail}`);
    return result;
 }

@@ -386,7 +407,6 @@ async function _verifyKeyAndStartSession(olmDevice, oneTimeKey, userId, deviceIn
    return sid;
 }

-
 /**
 * Verify the signature on an object
 *
@@ -16,10 +16,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {logger} from '../../logger';
+import { logger } from '../../logger';
 import * as utils from "../../utils";

-export const VERSION = 9;
+export const VERSION = 10;
+const PROFILE_TRANSACTIONS = false;

 /**
 * Implementation of a CryptoStore which is backed by an existing
@@ -34,6 +35,7 @@ export class Backend {
     */
    constructor(db) {
        this._db = db;
+        this._nextTxnId = 0;

        // make sure we close the db on `onversionchange` - otherwise
        // attempts to delete the database will block (and subsequent
@@ -228,7 +230,7 @@ export class Backend {
            const cursor = ev.target.result;
            if (cursor) {
                const keyReq = cursor.value;
-                if (keyReq.recipients.includes({userId, deviceId})) {
+                if (keyReq.recipients.includes({ userId, deviceId })) {
                    results.push(keyReq);
                }
                cursor.continue();
@@ -494,7 +496,7 @@ export class Backend {
            const lastProblem = problems[problems.length - 1];
            for (const problem of problems) {
                if (problem.time > timestamp) {
-                    result = Object.assign({}, problem, {fixed: lastProblem.fixed});
+                    result = Object.assign({}, problem, { fixed: lastProblem.fixed });
                    return;
                }
            }
@@ -517,11 +519,11 @@ export class Backend {

        await Promise.all(devices.map((device) => {
            return new Promise((resolve) => {
-                const {userId, deviceInfo} = device;
+                const { userId, deviceInfo } = device;
                const getReq = objectStore.get([userId, deviceInfo.deviceId]);
                getReq.onsuccess = function() {
                    if (!getReq.result) {
-                        objectStore.put({userId, deviceId: deviceInfo.deviceId});
+                        objectStore.put({ userId, deviceId: deviceInfo.deviceId });
                        ret.push(device);
                    }
                    resolve();
@@ -757,10 +759,59 @@ export class Backend {
        }));
    }

-    doTxn(mode, stores, func) {
+    addSharedHistoryInboundGroupSession(roomId, senderKey, sessionId, txn) {
+        if (!txn) {
+            txn = this._db.transaction(
+                "shared_history_inbound_group_sessions", "readwrite",
+            );
+        }
+        const objectStore = txn.objectStore("shared_history_inbound_group_sessions");
+        const req = objectStore.get([roomId]);
+        req.onsuccess = () => {
+            const { sessions } = req.result || { sessions: [] };
+            sessions.push([senderKey, sessionId]);
+            objectStore.put({ roomId, sessions });
+        };
+    }
+
+    getSharedHistoryInboundGroupSessions(roomId, txn) {
+        if (!txn) {
+            txn = this._db.transaction(
+                "shared_history_inbound_group_sessions", "readonly",
+            );
+        }
+        const objectStore = txn.objectStore("shared_history_inbound_group_sessions");
+        const req = objectStore.get([roomId]);
+        return new Promise((resolve, reject) => {
+            req.onsuccess = () => {
+                const { sessions } = req.result || { sessions: [] };
+                resolve(sessions);
+            };
+            req.onerror = reject;
+        });
+    }
+
+    doTxn(mode, stores, func, log = logger) {
+        let startTime;
+        let description;
+        if (PROFILE_TRANSACTIONS) {
+            const txnId = this._nextTxnId++;
+            startTime = Date.now();
+            description = `${mode} crypto store transaction ${txnId} in ${stores}`;
+            log.debug(`Starting ${description}`);
+        }
        const txn = this._db.transaction(stores, mode);
        const promise = promiseifyTxn(txn);
        const result = func(txn);
+        if (PROFILE_TRANSACTIONS) {
+            promise.then(() => {
+                const elapsedTime = Date.now() - startTime;
+                log.debug(`Finished ${description}, took ${elapsedTime} ms`);
+            }, () => {
+                const elapsedTime = Date.now() - startTime;
+                log.error(`Failed ${description}, took ${elapsedTime} ms`);
+            });
+        }
        return promise.then(() => {
            return result;
        });
@@ -815,6 +866,11 @@ export function upgradeDatabase(db, oldVersion) {
            keyPath: ["userId", "deviceId"],
        });
    }
+    if (oldVersion < 10) {
+        db.createObjectStore("shared_history_inbound_group_sessions", {
+            keyPath: ["roomId"],
+        });
+    }
    // Expand as needed.
 }

@@ -16,11 +16,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {logger} from '../../logger';
-import {LocalStorageCryptoStore} from './localStorage-crypto-store';
-import {MemoryCryptoStore} from './memory-crypto-store';
+import { logger } from '../../logger';
+import { LocalStorageCryptoStore } from './localStorage-crypto-store';
+import { MemoryCryptoStore } from './memory-crypto-store';
 import * as IndexedDBCryptoStoreBackend from './indexeddb-crypto-store-backend';
-import {InvalidCryptoStoreError} from '../../errors';
+import { InvalidCryptoStoreError } from '../../errors';
 import * as IndexedDBHelpers from "../../indexeddb-helpers";

 /**
@@ -582,6 +582,29 @@ export class IndexedDBCryptoStore {
        return this._backend.markSessionsNeedingBackup(sessions, txn);
    }

+    /**
+     * Add a shared-history group session for a room.
+     * @param {string} roomId The room that the key belongs to
+     * @param {string} senderKey The sender's curve 25519 key
+     * @param {string} sessionId The ID of the session
+     * @param {*} txn An active transaction. See doTxn(). (optional)
+     */
+    addSharedHistoryInboundGroupSession(roomId, senderKey, sessionId, txn) {
+        this._backend.addSharedHistoryInboundGroupSession(
+            roomId, senderKey, sessionId, txn,
+        );
+    }
+
+    /**
+     * Get the shared-history group session for a room.
+     * @param {string} roomId The room that the key belongs to
+     * @param {*} txn An active transaction. See doTxn(). (optional)
+     * @returns {Promise} Resolves to an array of [senderKey, sessionId]
+     */
+    getSharedHistoryInboundGroupSessions(roomId, txn) {
+        return this._backend.getSharedHistoryInboundGroupSessions(roomId, txn);
+    }
+
    /**
     * Perform a transaction on the crypto store. Any store methods
     * that require a transaction (txn) object to be passed in may
@@ -596,6 +619,7 @@ export class IndexedDBCryptoStore {
     * @param {function(*)} func Function called with the
     *     transaction object: an opaque object that should be passed
     *     to store functions.
+     * @param {Logger} [log] A possibly customised log
     * @return {Promise} Promise that resolves with the result of the `func`
     *     when the transaction is complete. If the backend is
     *     async (ie. the indexeddb backend) any of the callback
@@ -603,8 +627,8 @@ export class IndexedDBCryptoStore {
     *     reject with that exception. On synchronous backends, the
     *     exception will propagate to the caller of the getFoo method.
     */
-    doTxn(mode, stores, func) {
-        return this._backend.doTxn(mode, stores, func);
+    doTxn(mode, stores, func, log) {
+        return this._backend.doTxn(mode, stores, func, log);
    }
 }

@@ -613,6 +637,8 @@ IndexedDBCryptoStore.STORE_SESSIONS = 'sessions';
 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS = 'inbound_group_sessions';
 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD
    = 'inbound_group_sessions_withheld';
+IndexedDBCryptoStore.STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS
+    = 'shared_history_inbound_group_sessions';
 IndexedDBCryptoStore.STORE_DEVICE_DATA = 'device_data';
 IndexedDBCryptoStore.STORE_ROOMS = 'rooms';
 IndexedDBCryptoStore.STORE_BACKUP = 'sessions_needing_backup';
@@ -15,8 +15,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {logger} from '../../logger';
-import {MemoryCryptoStore} from './memory-crypto-store';
+import { logger } from '../../logger';
+import { MemoryCryptoStore } from './memory-crypto-store';

 /**
 * Internal module. Partial localStorage backed storage for e2e.
@@ -136,7 +136,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
    async storeEndToEndSessionProblem(deviceKey, type, fixed) {
        const key = keyEndToEndSessionProblems(deviceKey);
        const problems = getJsonItem(this.store, key) || [];
-        problems.push({type, fixed, time: Date.now()});
+        problems.push({ type, fixed, time: Date.now() });
        problems.sort((a, b) => {
            return a.time - b.time;
        });
@@ -152,7 +152,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        const lastProblem = problems[problems.length - 1];
        for (const problem of problems) {
            if (problem.time > timestamp) {
-                return Object.assign({}, problem, {fixed: lastProblem.fixed});
+                return Object.assign({}, problem, { fixed: lastProblem.fixed });
            }
        }
        if (lastProblem.fixed) {
@@ -168,7 +168,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        const ret = [];

        for (const device of devices) {
-            const {userId, deviceInfo} = device;
+            const { userId, deviceInfo } = device;
            if (userId in notifiedErrorDevices) {
                if (!(deviceInfo.deviceId in notifiedErrorDevices[userId])) {
                    ret.push(device);
@@ -176,7 +176,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
                }
            } else {
                ret.push(device);
-                notifiedErrorDevices[userId] = {[deviceInfo.deviceId]: true };
+                notifiedErrorDevices[userId] = { [deviceInfo.deviceId]: true };
            }
        }

@@ -16,7 +16,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {logger} from '../../logger';
+import { logger } from '../../logger';
 import * as utils from "../../utils";

 /**
@@ -51,6 +51,8 @@ export class MemoryCryptoStore {
        this._rooms = {};
        // Set of {senderCurve25519Key+'/'+sessionId}
        this._sessionsNeedingBackup = {};
+        // roomId -> array of [senderKey, sessionId]
+        this._sharedHistoryInboundGroupSessions = {};
    }

    /**
@@ -184,7 +186,7 @@ export class MemoryCryptoStore {

        for (const req of this._outgoingRoomKeyRequests) {
            for (const state of wantedStates) {
-                if (req.state === state && req.recipients.includes({userId, deviceId})) {
+                if (req.state === state && req.recipients.includes({ userId, deviceId })) {
                    results.push(req);
                }
            }
@@ -322,7 +324,7 @@ export class MemoryCryptoStore {
    async storeEndToEndSessionProblem(deviceKey, type, fixed) {
        const problems = this._sessionProblems[deviceKey]
              = this._sessionProblems[deviceKey] || [];
-        problems.push({type, fixed, time: Date.now()});
+        problems.push({ type, fixed, time: Date.now() });
        problems.sort((a, b) => {
            return a.time - b.time;
        });
@@ -336,7 +338,7 @@ export class MemoryCryptoStore {
        const lastProblem = problems[problems.length - 1];
        for (const problem of problems) {
            if (problem.time > timestamp) {
-                return Object.assign({}, problem, {fixed: lastProblem.fixed});
+                return Object.assign({}, problem, { fixed: lastProblem.fixed });
            }
        }
        if (lastProblem.fixed) {
@@ -351,7 +353,7 @@ export class MemoryCryptoStore {
        const ret = [];

        for (const device of devices) {
-            const {userId, deviceInfo} = device;
+            const { userId, deviceInfo } = device;
            if (userId in notifiedErrorDevices) {
                if (!(deviceInfo.deviceId in notifiedErrorDevices[userId])) {
                    ret.push(device);
@@ -359,7 +361,7 @@ export class MemoryCryptoStore {
                }
            } else {
                ret.push(device);
-                notifiedErrorDevices[userId] = {[deviceInfo.deviceId]: true };
+                notifiedErrorDevices[userId] = { [deviceInfo.deviceId]: true };
            }
        }

@@ -467,6 +469,16 @@ export class MemoryCryptoStore {
        return Promise.resolve();
    }

+    addSharedHistoryInboundGroupSession(roomId, senderKey, sessionId) {
+        const sessions = this._sharedHistoryInboundGroupSessions[roomId] || [];
+        sessions.push([senderKey, sessionId]);
+        this._sharedHistoryInboundGroupSessions[roomId] = sessions;
+    }
+
+    getSharedHistoryInboundGroupSessions(roomId) {
+        return Promise.resolve(this._sharedHistoryInboundGroupSessions[roomId] || []);
+    }
+
    // Session key backups

    doTxn(mode, stores, func) {
@@ -20,12 +20,12 @@ limitations under the License.
 * @module crypto/verification/Base
 */

-import {MatrixEvent} from '../../models/event';
-import {EventEmitter} from 'events';
-import {logger} from '../../logger';
-import {DeviceInfo} from '../deviceinfo';
-import {newTimeoutError} from "./Error";
-import {requestKeysDuringVerification} from "../CrossSigning";
+import { MatrixEvent } from '../../models/event';
+import { EventEmitter } from 'events';
+import { logger } from '../../logger';
+import { DeviceInfo } from '../deviceinfo';
+import { newTimeoutError } from "./Error";
+import { requestKeysDuringVerification } from "../CrossSigning";

 const timeoutException = new Error("Verification timed out");

@@ -138,7 +138,7 @@ export class VerificationBase extends EventEmitter {
    switchStartEvent(event) {
        if (this.canSwitchStartEvent(event)) {
            logger.log("Verification Base: switching verification start event",
-                {restartingFlow: !!this._rejectEvent});
+                { restartingFlow: !!this._rejectEvent });
            if (this._rejectEvent) {
                const reject = this._rejectEvent;
                this._rejectEvent = undefined;
@@ -167,7 +167,7 @@ export class VerificationBase extends EventEmitter {
            // there is only promise to reject if verify has been called
            if (reject) {
                const content = e.getContent();
-                const {reason, code} = content;
+                const { reason, code } = content;
                reject(new Error(`Other side cancelled verification ` +
                    `because ${reason} (${code})`));
            }
@@ -20,10 +20,10 @@ limitations under the License.
 * @module crypto/verification/Error
 */

-import {MatrixEvent} from "../../models/event";
+import { MatrixEvent } from "../../models/event";

 export function newVerificationError(code, reason, extradata) {
-    const content = Object.assign({}, {code, reason}, extradata);
+    const content = Object.assign({}, { code, reason }, extradata);
    return new MatrixEvent({
        type: "m.key.verification.cancel",
        content,
@@ -87,9 +87,9 @@ export const newInvalidMessageError = errorFactory(
 export function errorFromEvent(event) {
    const content = event.getContent();
    if (content) {
-        const {code, reason} = content;
-        return {code, reason};
+        const { code, reason } = content;
+        return { code, reason };
    } else {
-        return {code: "Unknown error", reason: "m.unknown"};
+        return { code: "Unknown error", reason: "m.unknown" };
    }
 }
@@ -20,7 +20,7 @@ limitations under the License.
 * @module crypto/verification/IllegalMethod
 */

-import {VerificationBase as Base} from "./Base";
+import { VerificationBase as Base } from "./Base";

 /**
 * @class crypto/verification/IllegalMethod/IllegalMethod
@@ -20,13 +20,13 @@ limitations under the License.
 * @module crypto/verification/QRCode
 */

-import {VerificationBase as Base} from "./Base";
+import { VerificationBase as Base } from "./Base";
 import {
    newKeyMismatchError,
    newUserCancelledError,
 } from './Error';
-import {encodeUnpaddedBase64, decodeBase64} from "../olmlib";
-import {logger} from '../../logger';
+import { encodeUnpaddedBase64, decodeBase64 } from "../olmlib";
+import { logger } from '../../logger';

 export const SHOW_QR_CODE_METHOD = "m.qr_code.show.v1";
 export const SCAN_QR_CODE_METHOD = "m.qr_code.scan.v1";
@@ -51,7 +51,7 @@ export class ReciprocateQRCode extends Base {
                "with this method yet.");
        }

-        const {qrCodeData} = this.request;
+        const { qrCodeData } = this.request;
        // 1. check the secret
        if (this.startEvent.getContent()['secret'] !== qrCodeData.encodedSharedSecret) {
            throw newKeyMismatchError();
@@ -19,7 +19,7 @@ limitations under the License.
 * @module crypto/verification/SAS
 */

-import {VerificationBase as Base, SwitchStartEventError} from "./Base";
+import { VerificationBase as Base, SwitchStartEventError } from "./Base";
 import anotherjson from 'another-json';
 import {
    errorFactory,
@@ -28,7 +28,7 @@ import {
    newUnknownMethodError,
    newUserCancelledError,
 } from './Error';
-import {logger} from '../../logger';
+import { logger } from '../../logger';

 const START_TYPE = "m.key.verification.start";

@@ -323,7 +323,6 @@ export class SAS extends Base {
                key: this.ourSASPubKey,
            });

-
            e = await this._waitForEvent("m.key.verification.key");
            // FIXME: make sure event is properly formed
            content = e.getContent();
@@ -353,7 +352,6 @@ export class SAS extends Base {
                this.emit("show_sas", this.sasEvent);
            });

-
            [e] = await Promise.all([
                this._waitForEvent("m.key.verification.mac")
                    .then((e) => {
@@ -411,7 +409,6 @@ export class SAS extends Base {
                commitment: olmutil.sha256(commitmentStr),
            });

-
            let e = await this._waitForEvent("m.key.verification.key");
            // FIXME: make sure event is properly formed
            content = e.getContent();
@@ -440,7 +437,6 @@ export class SAS extends Base {
                this.emit("show_sas", this.sasEvent);
            });

-
            [e] = await Promise.all([
                this._waitForEvent("m.key.verification.mac")
                    .then((e) => {
@@ -21,7 +21,7 @@ import {
    READY_TYPE,
    START_TYPE,
 } from "./VerificationRequest";
-import {logger} from '../../../logger';
+import { logger } from '../../../logger';

 const MESSAGE_TYPE = "m.room.message";
 const M_REFERENCE = "m.reference";
@@ -157,7 +157,7 @@ export class InRoomChannel {
        if (type === MESSAGE_TYPE) {
            const content = event.getContent();
            if (content) {
-                const {msgtype} = content;
+                const { msgtype } = content;
                if (msgtype === REQUEST_TYPE) {
                    return REQUEST_TYPE;
                }
@@ -15,8 +15,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {randomString} from '../../../randomstring';
-import {logger} from '../../../logger';
+import { randomString } from '../../../randomstring';
+import { logger } from '../../../logger';
 import {
    CANCEL_TYPE,
    PHASE_STARTED,
@@ -26,8 +26,8 @@ import {
    START_TYPE,
    VerificationRequest,
 } from "./VerificationRequest";
-import {errorFromEvent, newUnexpectedMessageError} from "../Error";
-import {MatrixEvent} from "../../../models/event";
+import { errorFromEvent, newUnexpectedMessageError } from "../Error";
+import { MatrixEvent } from "../../../models/event";

 /**
 * A key verification channel that sends verification events over to_device messages.
@@ -179,7 +179,9 @@ export class ToDeviceChannel {
        const isAcceptingEvent = type === START_TYPE || type === READY_TYPE;
        // the request has picked a ready or start event, tell the other devices about it
        if (isAcceptingEvent && !wasStarted && isStarted && this._deviceId) {
-            const nonChosenDevices = this._devices.filter(d => d !== this._deviceId);
+            const nonChosenDevices = this._devices.filter(
+                d => d !== this._deviceId && d !== this._client.getDeviceId(),
+            );
            if (nonChosenDevices.length) {
                const message = this.completeContent({
                    code: "m.accepted",
@@ -275,7 +277,7 @@ export class ToDeviceChannel {
                msgMap[deviceId] = content;
            }

-            return this._client.sendToDevice(type, {[this.userId]: msgMap});
+            return this._client.sendToDevice(type, { [this.userId]: msgMap });
        } else {
            return Promise.resolve();
        }
@@ -290,7 +292,6 @@ export class ToDeviceChannel {
    }
 }

-
 export class ToDeviceRequests {
    constructor() {
        this._requestsByUserId = new Map();
@@ -15,15 +15,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import {logger} from '../../../logger';
-import {EventEmitter} from 'events';
+import { logger } from '../../../logger';
+import { EventEmitter } from 'events';
 import {
    errorFactory,
    errorFromEvent,
    newUnexpectedMessageError,
    newUnknownMethodError,
 } from "../Error";
-import {QRCodeData, SCAN_QR_CODE_METHOD} from "../QRCode";
+import { QRCodeData, SCAN_QR_CODE_METHOD } from "../QRCode";

 // How long after the event's timestamp that the request times out
 const TIMEOUT_FROM_EVENT_TS = 10 * 60 * 1000; // 10 minutes
@@ -37,7 +37,6 @@ const TIMEOUT_FROM_EVENT_RECEIPT = 2 * 60 * 1000; // 2 minutes
 // are this amount of time away from expiring.
 const VERIFICATION_REQUEST_MARGIN = 3 * 1000; // 3 seconds

-
 export const EVENT_PREFIX = "m.key.verification.";
 export const REQUEST_TYPE = EVENT_PREFIX + "request";
 export const START_TYPE = EVENT_PREFIX + "start";
@@ -52,7 +51,6 @@ export const PHASE_STARTED = 4;
 export const PHASE_CANCELLED = 5;
 export const PHASE_DONE = 6;

-
 /**
 * State machine for verification requests.
 * Things that differ based on what channel is used to
@@ -98,7 +96,6 @@ export class VerificationRequest extends EventEmitter {
    static validateEvent(type, event, client) {
        const content = event.getContent();

-
        if (!type || !type.startsWith(EVENT_PREFIX)) {
            return false;
        }
@@ -265,7 +262,7 @@ export class VerificationRequest extends EventEmitter {
        if (!content) {
            return false;
        }
-        const {methods} = content;
+        const { methods } = content;
        if (!Array.isArray(methods)) {
            return false;
        }
@@ -355,7 +352,6 @@ export class VerificationRequest extends EventEmitter {
        return this._observeOnly;
    }

-
    /**
     * Gets which device the verification should be started with
     * given the events sent so far in the verification. This is the
@@ -414,7 +410,7 @@ export class VerificationRequest extends EventEmitter {
    async sendRequest() {
        if (!this.observeOnly && this._phase === PHASE_UNSENT) {
            const methods = [...this._verificationMethods.keys()];
-            await this.channel.send(REQUEST_TYPE, {methods});
+            await this.channel.send(REQUEST_TYPE, { methods });
        }
    }

@@ -424,7 +420,7 @@ export class VerificationRequest extends EventEmitter {
     * @param {string?} error.code the error code to send the cancellation with
     * @returns {Promise} resolves when the event has been sent.
     */
-    async cancel({reason = "User declined", code = "m.user"} = {}) {
+    async cancel({ reason = "User declined", code = "m.user" } = {}) {
        if (!this.observeOnly && this._phase !== PHASE_CANCELLED) {
            this._declining = true;
            this.emit("change");
@@ -432,7 +428,7 @@ export class VerificationRequest extends EventEmitter {
                return this._verifier.cancel(errorFactory(code, reason)());
            } else {
                this._cancellingUserId = this._client.getUserId();
-                await this.channel.send(CANCEL_TYPE, {code, reason});
+                await this.channel.send(CANCEL_TYPE, { code, reason });
            }
        }
    }
@@ -446,7 +442,7 @@ export class VerificationRequest extends EventEmitter {
            const methods = [...this._verificationMethods.keys()];
            this._accepting = true;
            this.emit("change");
-            await this.channel.send(READY_TYPE, {methods});
+            await this.channel.send(READY_TYPE, { methods });
        }
    }

@@ -499,20 +495,20 @@ export class VerificationRequest extends EventEmitter {
    }

    _calculatePhaseTransitions() {
-        const transitions = [{phase: PHASE_UNSENT}];
+        const transitions = [{ phase: PHASE_UNSENT }];
        const phase = () => transitions[transitions.length - 1].phase;

        // always pass by .request first to be sure channel.userId has been set
        const hasRequestByThem = this._eventsByThem.has(REQUEST_TYPE);
        const requestEvent = this._getEventBy(REQUEST_TYPE, hasRequestByThem);
        if (requestEvent) {
-            transitions.push({phase: PHASE_REQUESTED, event: requestEvent});
+            transitions.push({ phase: PHASE_REQUESTED, event: requestEvent });
        }

        const readyEvent =
            requestEvent && this._getEventBy(READY_TYPE, !hasRequestByThem);
        if (readyEvent && phase() === PHASE_REQUESTED) {
-            transitions.push({phase: PHASE_READY, event: readyEvent});
+            transitions.push({ phase: PHASE_READY, event: readyEvent });
        }

        let startEvent;
@@ -535,18 +531,18 @@ export class VerificationRequest extends EventEmitter {
            const fromUnsentPhase = phase() === PHASE_UNSENT &&
                this.channel.constructor.canCreateRequest(START_TYPE);
            if (fromRequestPhase || phase() === PHASE_READY || fromUnsentPhase) {
-                transitions.push({phase: PHASE_STARTED, event: startEvent});
+                transitions.push({ phase: PHASE_STARTED, event: startEvent });
            }
        }

        const ourDoneEvent = this._eventsByUs.get(DONE_TYPE);
        if (this._verifierHasFinished || (ourDoneEvent && phase() === PHASE_STARTED)) {
-            transitions.push({phase: PHASE_DONE});
+            transitions.push({ phase: PHASE_DONE });
        }

        const cancelEvent = this._getEventByEither(CANCEL_TYPE);
        if ((this._cancelled || cancelEvent) && phase() !== PHASE_DONE) {
-            transitions.push({phase: PHASE_CANCELLED, event: cancelEvent});
+            transitions.push({ phase: PHASE_CANCELLED, event: cancelEvent });
            return transitions;
        }

@@ -554,7 +550,7 @@ export class VerificationRequest extends EventEmitter {
    }

    _transitionToPhase(transition) {
-        const {phase, event} = transition;
+        const { phase, event } = transition;
        // get common methods
        if (phase === PHASE_REQUESTED || phase === PHASE_READY) {
            if (!this._wasSentByOwnDevice(event)) {
@@ -581,7 +577,7 @@ export class VerificationRequest extends EventEmitter {
        }
        // create verifier
        if (phase === PHASE_STARTED) {
-            const {method} = event.getContent();
+            const { method } = event.getContent();
            if (!this._verifier && !this.observeOnly) {
                this._verifier = this._createVerifier(method, event);
                if (!this._verifier) {
@@ -731,7 +727,7 @@ export class VerificationRequest extends EventEmitter {
                }

                const lastTransition = newTransitions[newTransitions.length - 1];
-                const {phase} = lastTransition;
+                const { phase } = lastTransition;

                this._setupTimeout(phase);
                // set phase as last thing as this emits the "change" event
@@ -809,7 +805,7 @@ export class VerificationRequest extends EventEmitter {
            logger.warn(`Cancelling, unexpected ${type} verification ` +
                `event from ${event.getSender()}`);
            const reason = `Unexpected ${type} event in phase ${this.phase}`;
-            await this.cancel(errorFromEvent(newUnexpectedMessageError({reason})));
+            await this.cancel(errorFromEvent(newUnexpectedMessageError({ reason })));
            return true;
        }
        return false;
@@ -849,7 +845,7 @@ export class VerificationRequest extends EventEmitter {
        if (!targetDevice) {
            targetDevice = this.targetDevice;
        }
-        const {userId, deviceId} = targetDevice;
+        const { userId, deviceId } = targetDevice;

        const VerifierCtor = this._verificationMethods.get(method);
        if (!VerifierCtor) {
@@ -22,7 +22,6 @@ InvalidStoreError.prototype = Object.create(Error.prototype, {
 });
 Reflect.setPrototypeOf(InvalidStoreError, Error);

-
 export function InvalidCryptoStoreError(reason) {
    const message = `Crypto store is invalid because ${reason}, ` +
        `please stop the client, delete all data and start the client again`;
@@ -19,7 +19,7 @@ limitations under the License.
 * @module filter
 */

-import {FilterComponent} from "./filter-component";
+import { FilterComponent } from "./filter-component";

 /**
 * @param {Object} obj
@@ -20,9 +20,9 @@ limitations under the License.
 * @module http-api
 */

-import {parse as parseContentType} from "content-type";
+import { parse as parseContentType } from "content-type";
 import * as utils from "./utils";
-import {logger} from './logger';
+import { logger } from './logger';

 // we use our own implementation of setTimeout, so that if we get suspended in
 // the middle of a /sync, we cancel the sync as soon as we awake, rather than
@@ -271,10 +271,10 @@ MatrixHttpApi.prototype = {
            xhr.timeout_timer = callbacks.setTimeout(timeout_fn, 30000);

            xhr.onreadystatechange = function() {
+                let resp;
                switch (xhr.readyState) {
                    case global.XMLHttpRequest.DONE:
                        callbacks.clearTimeout(xhr.timeout_timer);
-                        var resp;
                        try {
                            if (xhr.status === 0) {
                                throw new AbortError();
@@ -344,7 +344,7 @@ MatrixHttpApi.prototype = {
            promise = this.authedRequest(
                opts.callback, "POST", "/upload", queryParams, body, {
                    prefix: "/_matrix/media/r0",
-                    headers: {"Content-Type": contentType},
+                    headers: { "Content-Type": contentType },
                    json: false,
                    bodyParser: bodyParser,
                },
@@ -803,7 +803,8 @@ const requestCallback = function(
        }
        if (!err) {
            try {
-                if (response.statusCode >= 400) {
+                const httpStatus = response.status || response.statusCode; // XMLHttpRequest vs http.IncomingMessage
+                if (httpStatus >= 400) {
                    err = parseErrorResponse(response, body);
                } else if (bodyParser) {
                    body = bodyParser(body);
@@ -818,7 +819,7 @@ const requestCallback = function(
            userDefinedCallback(err);
        } else {
            const res = {
-                code: response.statusCode,
+                code: response.status || response.statusCode, // XMLHttpRequest vs http.IncomingMessage

                // XXX: why do we bother with this? it doesn't work for
                // XMLHttpRequest, so clearly we don't use it.
@@ -842,7 +843,7 @@ const requestCallback = function(
 * @returns {Error}
 */
 function parseErrorResponse(response, body) {
-    const httpStatus = response.statusCode;
+    const httpStatus = response.status || response.statusCode; // XMLHttpRequest vs http.IncomingMessage
    const contentType = getResponseContentType(response);

    let err;
@@ -862,7 +863,6 @@ function parseErrorResponse(response, body) {
    return err;
 }

-
 /**
 * extract the Content-Type header from the response object, and
 * parse it to a `{type, parameters}` object.
@@ -16,17 +16,17 @@ limitations under the License.

 import * as matrixcs from "./matrix";
 import * as utils from "./utils";
+import { logger } from './logger';
 import request from "request";

 matrixcs.request(request);
-utils.runPolyfills();

 try {
    // eslint-disable-next-line @typescript-eslint/no-var-requires
    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');
 }

 export * from "./matrix";
@@ -21,5 +21,5 @@ limitations under the License.
 */

 /** The {@link module:indexeddb-store-worker~IndexedDBStoreWorker} class. */
-export {IndexedDBStoreWorker} from "./store/indexeddb-store-worker";
+export { IndexedDBStoreWorker } from "./store/indexeddb-store-worker";

--- a/Show More
+++ b/Show More