v10.1.0-rc.1

Prepare changelog for v10.1.0-rc.1
Merge pull request #1681 from matrix-org/revert-1678-travis/event-logging
2021-05-04 15:37:55 +01:00 · 2021-05-04 15:37:54 +01:00 · 2021-05-02 19:11:06 -06:00 · 2021-05-02 19:10:47 -06:00 · 2021-04-28 17:18:07 +01:00 · 2021-04-28 09:30:04 -06:00
34 changed files with 1060 additions and 839 deletions
@@ -1,13 +1,12 @@
 module.exports = {
-    extends: ["matrix-org"],
    plugins: [
-        "babel",
+        "matrix-org",
    ],
+    extends: ["plugin:matrix-org/javascript"],
    env: {
        browser: true,
        node: true,
    },
-
    rules: {
        "no-var": ["warn"],
        "prefer-rest-params": ["warn"],
@@ -33,7 +32,7 @@ module.exports = {
    },
    overrides: [{
        "files": ["src/**/*.ts"],
-        "extends": ["matrix-org/ts"],
+        "extends": ["plugin:matrix-org/typescript"],
        "rules": {
            // We're okay being explicit at the moment
            "@typescript-eslint/no-empty-interface": "off",
@@ -1,3 +1,103 @@
+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)
@@ -1,6 +1,6 @@
 {
  "name": "matrix-js-sdk",
-  "version": "9.9.0",
+  "version": "10.1.0-rc.1",
  "description": "Matrix Client-Server SDK for Javascript",
  "scripts": {
    "prepublishOnly": "yarn build",
@@ -17,8 +17,9 @@
    "lint": "yarn lint:types && yarn lint:js",
    "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",
@@ -61,6 +62,8 @@
  "devDependencies": {
    "@babel/cli": "^7.12.10",
    "@babel/core": "^7.12.10",
+    "@babel/eslint-parser": "^7.12.10",
+    "@babel/eslint-plugin": "^7.12.10",
    "@babel/plugin-proposal-class-properties": "^7.12.1",
    "@babel/plugin-proposal-numeric-separator": "^7.12.7",
    "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
@@ -72,15 +75,16 @@
    "@types/jest": "^26.0.20",
    "@types/node": "12",
    "@types/request": "^2.48.5",
-    "babel-eslint": "^10.1.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": "^17.0.0",
    "docdash": "^1.2.0",
    "eslint": "7.18.0",
-    "eslint-config-matrix-org": "^0.2.0",
-    "eslint-plugin-babel": "^5.3.1",
+    "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": "^26.6.3",
@@ -94,7 +98,16 @@
    "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"
 }
@@ -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']);
+        });
+    });
 });
@@ -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,
+                });
            });
        });

@@ -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 {
@@ -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);
@@ -3,6 +3,7 @@ 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";
@@ -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({
@@ -282,4 +282,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);
+        });
+    });
 });
@@ -15,7 +15,7 @@ limitations under the License.
 */

 import {TestClient} from '../../TestClient';
-import {MatrixCall, CallErrorCode} from '../../../src/webrtc/call';
+import {MatrixCall, CallErrorCode, CallEvent} from '../../../src/webrtc/call';

 const DUMMY_SDP = (
    "v=0\r\n" +
@@ -254,4 +254,48 @@ describe('Call', function() {
            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);
+    });
 });
@@ -53,10 +53,13 @@ export enum EventType {
    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",

@@ -246,10 +246,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) {
@@ -1518,6 +1533,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
 *
@@ -500,19 +500,8 @@ MatrixClient.prototype.rehydrateDevice = async function() {
        return;
    }

-    let getDeviceResult;
-    try {
-        getDeviceResult = await this._http.authedRequest(
-            undefined,
-            "GET",
-            "/dehydrated_device",
-            undefined, undefined,
-            {
-                prefix: "/_matrix/client/unstable/org.matrix.msc2697.v2",
-            },
-        );
-    } catch (e) {
-        logger.info("could not get dehydrated device", e.toString());
+    const getDeviceResult = await this.getDehydratedDevice();
+    if (!getDeviceResult) {
        return;
    }

@@ -574,6 +563,27 @@ MatrixClient.prototype.rehydrateDevice = async function() {
    }
 };

+/**
+ * Get the current dehydrated device, if any
+ * @return {Promise} A promise of an object containing the dehydrated device
+ */
+MatrixClient.prototype.getDehydratedDevice = async function() {
+    try {
+        return await this._http.authedRequest(
+            undefined,
+            "GET",
+            "/dehydrated_device",
+            undefined, undefined,
+            {
+                prefix: "/_matrix/client/unstable/org.matrix.msc2697.v2",
+            },
+        );
+    } catch (e) {
+        logger.info("could not get dehydrated device", e.toString());
+        return;
+    }
+};
+
 /**
 * Set the dehydration key.  This will also periodically dehydrate devices to
 * the server.
@@ -719,6 +729,17 @@ MatrixClient.prototype.setSupportsCallTransfer = function(supportsCallTransfer)
    this._supportsCallTransfer = supportsCallTransfer;
 };

+/**
+ * Creates a new call.
+ * The place*Call methods on the returned call can be used to actually place a call
+ *
+ * @param {string} roomId The room the call is to be placed in.
+ * @return {MatrixCall} the call or null if the browser doesn't support calling.
+ */
+MatrixClient.prototype.createCall = function(roomId) {
+    return createNewMatrixCall(this, roomId);
+};
+
 /**
 * Get the current sync state.
 * @return {?string} the sync state, which may be null.
@@ -2293,6 +2314,39 @@ MatrixClient.prototype.deleteKeysFromBackup = function(roomId, sessionId, versio
    );
 };

+/**
+ * Share shared-history decryption keys with the given users.
+ *
+ * @param {string} roomId the room for which keys should be shared.
+ * @param {array} userIds a list of users to share with.  The keys will be sent to
+ *     all of the user's current devices.
+ */
+MatrixClient.prototype.sendSharedHistoryKeys = async function(roomId, userIds) {
+    if (this._crypto === null) {
+        throw new Error("End-to-end encryption disabled");
+    }
+
+    const roomEncryption = this._roomList.getRoomEncryption(roomId);
+    if (!roomEncryption) {
+        // unknown room, or unencrypted room
+        logger.error("Unknown room.  Not sharing decryption keys");
+        return;
+    }
+
+    const deviceInfos = await this._crypto.downloadKeys(userIds);
+    const devicesByUser = {};
+    for (const [userId, devices] of Object.entries(deviceInfos)) {
+        devicesByUser[userId] = Object.values(devices);
+    }
+
+    const alg = this._crypto._getRoomDecryptor(roomId, roomEncryption.algorithm);
+    if (alg.sendSharedHistoryInboundSessions) {
+        await alg.sendSharedHistoryInboundSessions(devicesByUser);
+    } else {
+        logger.warning("Algorithm does not support sharing previous keys", roomEncryption.algorithm);
+    }
+};
+
 // Group ops
 // =========
 // Operations on groups that come down the sync stream (ie. ones the
@@ -4756,7 +4810,8 @@ MatrixClient.prototype._processRoomEventsSearch = function(searchResults, respon
    searchResults.highlights = Object.keys(highlights);

    // append the new results to our existing results
-    for (let i = 0; i < room_events.results.length; i++) {
+    const resultsLength = room_events.results ? room_events.results.length : 0;
+    for (let i = 0; i < resultsLength; i++) {
        const sr = SearchResult.fromJson(room_events.results[i], this.getEventMapper());
        searchResults.results.push(sr);
    }
@@ -28,7 +28,7 @@ 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 {chunkPromises, defer, sleep} from '../utils';


 /* State transition diagram for DeviceList._deviceTrackingStatus
@@ -62,7 +62,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 +98,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 +783,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
@@ -1048,6 +1048,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(
@@ -1104,6 +1105,12 @@ 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();
                    }
@@ -1383,6 +1390,7 @@ OlmDevice.prototype.getInboundGroupSessionKey = async function(
                        "forwarding_curve25519_key_chain":
                            sessionData.forwardingCurve25519KeyChain || [],
                        "sender_claimed_ed25519_key": senderEd25519Key,
+                        "shared_history": sessionData.sharedHistory || false,
                    };
                },
            );
@@ -1415,10 +1423,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
 // =========

@@ -36,11 +36,27 @@ import {

 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,12 +66,13 @@ 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;
 }


@@ -183,6 +200,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 +210,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 +222,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 +244,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 +275,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(
@@ -374,15 +400,18 @@ 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},
    );

    // don't wait for it to complete
@@ -391,7 +420,7 @@ MegolmEncryption.prototype._prepareNewSession = async function() {
        sessionId, key.key,
    );

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

 /**
@@ -672,14 +701,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,
        },
    };

@@ -901,7 +931,7 @@ MegolmEncryption.prototype.prepareToEncrypt = function(room) {
            }

            logger.debug(`Ensuring outbound session in ${this._roomId}`);
-            await this._ensureOutboundSession(devicesInRoom, blocked, true);
+            await this._ensureOutboundSession(room, devicesInRoom, blocked, true);

            logger.debug(`Ready to encrypt events for ${this._roomId}`);
        } catch (e) {
@@ -945,7 +975,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,
@@ -1370,10 +1400,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)
@@ -1573,14 +1607,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,
        },
    };
 };
@@ -1594,6 +1629,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,
@@ -1602,7 +1644,7 @@ MegolmDecryption.prototype.importRoomKey = function(session, opts = {}) {
        session.session_key,
        session.sender_claimed_keys,
        true,
-        opts.untrusted ? { untrusted: opts.untrusted } : {},
+        extraSessionData,
    ).then(() => {
        if (opts.source !== "backup") {
            // don't wait for it to complete
@@ -1681,6 +1723,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,
 );
@@ -568,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
@@ -1300,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

@@ -1322,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();
        }
@@ -1348,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 {
@@ -1360,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();
        }
@@ -1374,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 {
@@ -1382,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();
        }
@@ -19,7 +19,7 @@ limitations under the License.
 import {logger} from '../../logger';
 import * as utils from "../../utils";

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

 /**
@@ -759,6 +759,38 @@ export class Backend {
        }));
    }

+    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;
@@ -834,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.
 }

@@ -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
@@ -614,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';
@@ -51,6 +51,8 @@ export class MemoryCryptoStore {
        this._rooms = {};
        // Set of {senderCurve25519Key+'/'+sessionId}
        this._sessionsNeedingBackup = {};
+        // roomId -> array of [senderKey, sessionId]
+        this._sharedHistoryInboundGroupSessions = {};
    }

    /**
@@ -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) {
@@ -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",
@@ -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();
@@ -36,11 +36,11 @@ const DEFAULT_NAMESPACE = "matrix";
 // when logging so we always get the current value of console methods.
 log.methodFactory = function(methodName, logLevel, loggerName) {
    return function(...args) {
-        /* eslint-disable babel/no-invalid-this */
+        /* eslint-disable @babel/no-invalid-this */
        if (this.prefix) {
            args.unshift(this.prefix);
        }
-        /* eslint-enable babel/no-invalid-this */
+        /* eslint-enable @babel/no-invalid-this */
        const supportedByConsole = methodName === "error" ||
            methodName === "warn" ||
            methodName === "trace" ||
@@ -168,7 +168,7 @@ export const MatrixEvent = function(
    /* The txnId with which this event was sent if it was during this session,
       allows for a unique ID which does not change when the event comes back down sync.
     */
-    this._txnId = null;
+    this._txnId = event.txn_id || null;

    /* Set an approximate timestamp for the event relative the local clock.
     * This will inherently be approximate because it doesn't take into account
@@ -351,8 +351,14 @@ RoomState.prototype.setStateEvents = function(stateEvents) {
        } else if (event.getType() === "m.room.power_levels") {
            const members = utils.values(self.members);
            utils.forEach(members, function(member) {
+                // We only propagate `RoomState.members` event if the
+                // power levels has been changed
+                // large room suffer from large re-rendering especially when not needed
+                const oldLastModified = member.getLastModifiedTime();
                member.setPowerLevelEvent(event);
-                self.emit("RoomState.members", event, self, member);
+                if (oldLastModified !== member.getLastModifiedTime()) {
+                    self.emit("RoomState.members", event, self, member);
+                }
            });

            // assume all our sentinels are now out-of-date
@@ -123,6 +123,8 @@ export function Room(roomId, client, myUserId, opts) {
    opts = opts || {};
    opts.pendingEventOrdering = opts.pendingEventOrdering || "chronological";

+    this._client = client;
+
    // In some cases, we add listeners for every displayed Matrix event, so it's
    // common to have quite a few more than the default limit.
    this.setMaxListeners(100);
@@ -189,6 +191,18 @@ export function Room(roomId, client, myUserId, opts) {

    if (this._opts.pendingEventOrdering == "detached") {
        this._pendingEventList = [];
+        const serializedPendingEventList = client._sessionStore.store.getItem(pendingEventsKey(this.roomId));
+        if (serializedPendingEventList) {
+            JSON.parse(serializedPendingEventList)
+                .forEach(async serializedEvent => {
+                    const event = new MatrixEvent(serializedEvent);
+                    if (event.getType() === "m.room.encrypted") {
+                        await event.attemptDecryption(this._client._crypto);
+                    }
+                    event.setStatus(EventStatus.NOT_SENT);
+                    this.addPendingEvent(event, event.getTxnId());
+                });
+        }
    }

    // read by megolm; boolean value - null indicates "use global value"
@@ -197,7 +211,6 @@ export function Room(roomId, client, myUserId, opts) {
    this._summaryHeroes = null;
    // awaited by getEncryptionTargetMembers while room members are loading

-    this._client = client;
    if (!this._opts.lazyLoadMembers) {
        this._membersPromise = Promise.resolve();
    } else {
@@ -205,6 +218,14 @@ export function Room(roomId, client, myUserId, opts) {
    }
 }

+/**
+ * @param {string} roomId ID of the current room
+ * @returns {string} Storage key to retrieve pending events
+ */
+function pendingEventsKey(roomId) {
+    return `mx_pending_events_${roomId}`;
+}
+
 utils.inherits(Room, EventEmitter);

 /**
@@ -357,6 +378,31 @@ Room.prototype.getPendingEvents = function() {
    return this._pendingEventList;
 };

+/**
+ * Removes a pending event for this room
+ *
+ * @param {string} eventId
+ * @return {boolean} True if an element was removed.
+ */
+Room.prototype.removePendingEvent = function(eventId) {
+    if (this._opts.pendingEventOrdering !== "detached") {
+        throw new Error(
+            "Cannot call removePendingEvent with pendingEventOrdering == " +
+                this._opts.pendingEventOrdering);
+    }
+
+    const removed = utils.removeElement(
+        this._pendingEventList,
+        function(ev) {
+            return ev.getId() == eventId;
+        }, false,
+    );
+
+    this._savePendingEvents();
+
+    return removed;
+};
+
 /**
 * Check whether the pending event list contains a given event by ID.
 * If pending event ordering is not "detached" then this returns false.
@@ -936,6 +982,15 @@ Room.prototype.addEventsToTimeline = function(events, toStartOfTimeline,
     return this.currentState.getMember(userId);
 };

+/**
+ * Get all currently loaded members from the current
+ * room state.
+ * @returns {RoomMember[]} Room members
+ */
+Room.prototype.getMembers = function() {
+    return this.currentState.getMembers();
+};
+
 /**
 * Get a list of members whose membership state is "join".
 * @return {RoomMember[]} A list of currently joined members.
@@ -1192,7 +1247,7 @@ Room.prototype._addLiveEvent = function(event, duplicateStrategy, fromCache) {
 * unique transaction id.
 */
 Room.prototype.addPendingEvent = function(event, txnId) {
-    if (event.status !== EventStatus.SENDING) {
+    if (event.status !== EventStatus.SENDING && event.status !== EventStatus.NOT_SENT) {
        throw new Error("addPendingEvent called on an event with status " +
                        event.status);
    }
@@ -1219,7 +1274,7 @@ Room.prototype.addPendingEvent = function(event, txnId) {
            event.setStatus(EventStatus.NOT_SENT);
        }
        this._pendingEventList.push(event);
-
+        this._savePendingEvents();
        if (event.isRelation()) {
            // For pending events, add them to the relations collection immediately.
            // (The alternate case below already covers this as part of adding to
@@ -1256,6 +1311,46 @@ Room.prototype.addPendingEvent = function(event, txnId) {

    this.emit("Room.localEchoUpdated", event, this, null, null);
 };
+
+/**
+ * Persists all pending events to local storage
+ *
+ * If the current room is encrypted only encrypted events will be persisted
+ * all messages that are not yet encrypted will be discarded
+ *
+ * This is because the flow of EVENT_STATUS transition is
+ * queued => sending => encrypting => sending => sent
+ *
+ * Steps 3 and 4 are skipped for unencrypted room.
+ * It is better to discard an unencrypted message rather than persisting
+ * it locally for everyone to read
+ */
+Room.prototype._savePendingEvents = function() {
+    if (this._pendingEventList) {
+        const pendingEvents = this._pendingEventList.map(event => {
+            return {
+                ...event.event,
+                txn_id: event.getTxnId(),
+            };
+        }).filter(event => {
+            // Filter out the unencrypted messages if the room is encrypted
+            const isEventEncrypted = event.type === "m.room.encrypted";
+            const isRoomEncrypted = this._client.isRoomEncrypted(this.roomId);
+            return isEventEncrypted || !isRoomEncrypted;
+        });
+
+        const { store } = this._client._sessionStore;
+        if (this._pendingEventList.length > 0) {
+            store.setItem(
+                pendingEventsKey(this.roomId),
+                JSON.stringify(pendingEvents),
+            );
+        } else {
+            store.removeItem(pendingEventsKey(this.roomId));
+        }
+    }
+};
+
 /**
 * Used to aggregate the local echo for a relation, and also
 * for re-applying a relation after it's redaction has been cancelled,
@@ -1310,12 +1405,7 @@ Room.prototype._handleRemoteEcho = function(remoteEvent, localEvent) {

    // if it's in the pending list, remove it
    if (this._pendingEventList) {
-        utils.removeElement(
-            this._pendingEventList,
-            function(ev) {
-                return ev.getId() == oldEventId;
-            }, false,
-        );
+        this.removePendingEvent(oldEventId);
    }

    // replace the event source (this will preserve the plaintext payload if
@@ -1434,6 +1524,7 @@ Room.prototype.updatePendingEvent = function(event, newStatus, newEventId) {
        }
        this.removeEvent(oldEventId);
    }
+    this._savePendingEvents();

    this.emit("Room.localEchoUpdated", event, this, oldEventId, oldStatus);
 };
@@ -268,6 +268,10 @@ export function PushProcessor(client) {
            return cond.value === val;
        }

+        if (typeof cond.pattern !== 'string') {
+            return false;
+        }
+
        let regex;

        if (cond.key == 'content.body') {
@@ -16,7 +16,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-/* eslint-disable babel/no-invalid-this */
+/* eslint-disable @babel/no-invalid-this */

 import {MemoryStore} from "./memory";
 import * as utils from "../utils";
@@ -476,7 +476,7 @@ SyncApi.prototype.sync = function() {

    this._running = true;

-    if (global.window) {
+    if (global.window && global.window.addEventListener) {
        this._onOnlineBound = this._onOnline.bind(this);
        global.window.addEventListener("online", this._onOnlineBound, false);
    }
@@ -745,6 +745,15 @@ export function promiseTry<T>(fn: () => T): Promise<T> {
    return new Promise((resolve) => resolve(fn()));
 }

+// Creates and awaits all promises, running no more than `chunkSize` at the same time
+export async function chunkPromises<T>(fns: (() => Promise<T>)[], chunkSize: number): Promise<T[]> {
+    const results: T[] = [];
+    for (let i = 0; i < fns.length; i += chunkSize) {
+        results.push(...(await Promise.all(fns.slice(i, i + chunkSize).map(fn => fn()))));
+    }
+    return results;
+}
+
 // We need to be able to access the Node.js crypto library from within the
 // Matrix SDK without needing to `require("crypto")`, which will fail in
 // browsers.  So `index.ts` will call `setCrypto` to store it, and when we need
@@ -62,6 +62,11 @@ interface TurnServer {
    ttl?: number,
 }

+interface AssertedIdentity {
+    id: string,
+    displayName: string,
+}
+
 export enum CallState {
    Fledgling = 'fledgling',
    InviteSent = 'invite_sent',
@@ -101,6 +106,8 @@ export enum CallEvent {
    RemoteHoldUnhold = 'remote_hold_unhold',
    // backwards compat alias for LocalHoldUnhold: remove in a major version bump
    HoldUnhold = 'hold_unhold',
+
+    AssertedIdentityChanged = 'asserted_identity_changed',
 }

 export enum CallErrorCode {
@@ -206,9 +213,9 @@ export function getDesktopCapturerSources(): Promise<Array<DesktopCapturerSource
 }

 export class CallError extends Error {
-    code : string;
+    code: string;

-    constructor(code : CallErrorCode, msg: string, err: Error) {
+    constructor(code: CallErrorCode, msg: string, err: Error) {
        // Stil ldon't think there's any way to have proper nested errors
        super(msg + ": " + err);

@@ -292,6 +299,8 @@ export class MatrixCall extends EventEmitter {
    // the call) we buffer them up here so we can then add the ones from the party we pick
    private remoteCandidateBuffer = new Map<string, RTCIceCandidate[]>();

+    private remoteAssertedIdentity: AssertedIdentity;
+
    constructor(opts: CallOpts) {
        super();
        this.roomId = opts.roomId;
@@ -337,8 +346,8 @@ export class MatrixCall extends EventEmitter {
        logger.debug("placeVoiceCall");
        this.checkForErrorListener();
        const constraints = getUserMediaContraints(ConstraintsType.Audio);
-        await this.placeCallWithConstraints(constraints);
        this.type = CallType.Voice;
+        await this.placeCallWithConstraints(constraints);
    }

    /**
@@ -355,8 +364,8 @@ export class MatrixCall extends EventEmitter {
        this.localVideoElement = localVideoElement;
        this.remoteVideoElement = remoteVideoElement;
        const constraints = getUserMediaContraints(ConstraintsType.Video);
-        await this.placeCallWithConstraints(constraints);
        this.type = CallType.Video;
+        await this.placeCallWithConstraints(constraints);
    }

    /**
@@ -372,7 +381,7 @@ export class MatrixCall extends EventEmitter {
    async placeScreenSharingCall(
        remoteVideoElement: HTMLVideoElement,
        localVideoElement: HTMLVideoElement,
-        selectDesktopCapturerSource: () => Promise<DesktopCapturerSource>,
+        selectDesktopCapturerSource?: () => Promise<DesktopCapturerSource>,
    ) {
        logger.debug("placeScreenSharingCall");
        this.checkForErrorListener();
@@ -381,7 +390,11 @@ export class MatrixCall extends EventEmitter {

        try {
            const screenshareConstraints = await getScreenshareContraints(selectDesktopCapturerSource);
-            if (!screenshareConstraints) return;
+            if (!screenshareConstraints) {
+                this.terminate(CallParty.Local, CallErrorCode.NoUserMedia, false);
+                return;
+            }
+
            if (window.electron?.getDesktopCapturerSources) {
                // We are using Electron
                logger.debug("Getting screen stream using getUserMedia()...");
@@ -402,6 +415,7 @@ export class MatrixCall extends EventEmitter {
                    "Failed to get screen-sharing stream: ", err,
                ),
            );
+            this.terminate(CallParty.Local, CallErrorCode.NoUserMedia, false);
        }
        this.type = CallType.Video;
    }
@@ -414,6 +428,10 @@ export class MatrixCall extends EventEmitter {
        return Boolean(this.opponentCaps && this.opponentCaps["m.call.transferee"]);
    }

+    public getRemoteAssertedIdentity(): AssertedIdentity {
+        return this.remoteAssertedIdentity;
+    }
+
    /**
     * Retrieve the local <code>&lt;video&gt;</code> DOM element.
     * @return {Element} The dom element
@@ -445,7 +463,7 @@ export class MatrixCall extends EventEmitter {
     * video will be rendered to it immediately.
     * @param {Element} element The <code>&lt;video&gt;</code> DOM element.
     */
-    public async setLocalVideoElement(element : HTMLVideoElement) {
+    public async setLocalVideoElement(element: HTMLVideoElement) {
        this.localVideoElement = element;

        if (element && this.localAVStream && this.type === CallType.Video) {
@@ -466,7 +484,7 @@ export class MatrixCall extends EventEmitter {
     * the first received video-capable stream will be rendered to it immediately.
     * @param {Element} element The <code>&lt;video&gt;</code> DOM element.
     */
-    public setRemoteVideoElement(element : HTMLVideoElement) {
+    public setRemoteVideoElement(element: HTMLVideoElement) {
        if (element === this.remoteVideoElement) return;

        element.autoplay = true;
@@ -541,6 +559,7 @@ export class MatrixCall extends EventEmitter {
        this.chooseOpponent(event);
        try {
            await this.peerConn.setRemoteDescription(invite.offer);
+            await this.addBufferedIceCandidates();
        } catch (e) {
            logger.debug("Failed to set remote description", e);
            this.terminate(CallParty.Local, CallErrorCode.SetRemoteDescription, false);
@@ -659,6 +678,8 @@ export class MatrixCall extends EventEmitter {

        logger.debug("Ending call " + this.callId);
        this.terminate(CallParty.Local, reason, !suppressEvent);
+        // We don't want to send hangup here if we didn't even get to sending an invite
+        if (this.state === CallState.WaitLocalMedia) return;
        const content = {};
        // Continue to send no reason for user hangups temporarily, until
        // clients understand the user_hangup reason (voip v1)
@@ -985,7 +1006,7 @@ export class MatrixCall extends EventEmitter {
    private gotLocalIceCandidate = (event: RTCPeerConnectionIceEvent) => {
        if (event.candidate) {
            logger.debug(
-                "Got local ICE " + event.candidate.sdpMid + " candidate: " +
+                "Call " + this.callId + " got local ICE " + event.candidate.sdpMid + " candidate: " +
                event.candidate.candidate,
            );

@@ -1019,7 +1040,7 @@ export class MatrixCall extends EventEmitter {
        }
    };

-    onRemoteIceCandidatesReceived(ev: MatrixEvent) {
+    async onRemoteIceCandidatesReceived(ev: MatrixEvent) {
        if (this.callHasEnded()) {
            //debuglog("Ignoring remote ICE candidate because call has ended");
            return;
@@ -1051,7 +1072,7 @@ export class MatrixCall extends EventEmitter {
            return;
        }

-        this.addIceCandidates(cands);
+        await this.addIceCandidates(cands);
    }

    /**
@@ -1059,7 +1080,10 @@ export class MatrixCall extends EventEmitter {
     * @param {Object} msg
     */
    async onAnswerReceived(event: MatrixEvent) {
+        logger.debug(`Got answer for call ID ${this.callId} from party ID ${event.getContent().party_id}`);
+
        if (this.callHasEnded()) {
+            logger.debug(`Ignoring answer because call ID ${this.callId} has ended`);
            return;
        }

@@ -1072,6 +1096,7 @@ export class MatrixCall extends EventEmitter {
        }

        this.chooseOpponent(event);
+        await this.addBufferedIceCandidates();

        this.setState(CallState.Connecting);

@@ -1187,7 +1212,17 @@ export class MatrixCall extends EventEmitter {
        }
    }

-    private callHasEnded() : boolean {
+    async onAssertedIdentityReceived(event: MatrixEvent) {
+        if (!event.getContent().asserted_identity) return;
+
+        this.remoteAssertedIdentity = {
+            id: event.getContent().asserted_identity.id,
+            displayName: event.getContent().asserted_identity.display_name,
+        };
+        this.emit(CallEvent.AssertedIdentityChanged);
+    }
+
+    private callHasEnded(): boolean {
        // This exists as workaround to typescript trying to be clever and erroring
        // when putting if (this.state === CallState.Ended) return; twice in the same
        // function, even though that function is async.
@@ -1520,7 +1555,10 @@ export class MatrixCall extends EventEmitter {
        }
    }

-    async transfer(targetUserId: string, targetRoomId?: string) {
+    /*
+     * Transfers this call to another user
+     */
+    async transfer(targetUserId: string) {
        // Fetch the target user's global profile info: their room avatar / displayname
        // could be different in whatever room we shae with them.
        const profileInfo = await this.client.getProfileInfo(targetUserId);
@@ -1537,9 +1575,49 @@ export class MatrixCall extends EventEmitter {
            create_call: replacementId,
        } as MCallReplacesEvent;

-        if (targetRoomId) body.target_room = targetRoomId;
+        await this.sendVoipEvent(EventType.CallReplaces, body);

-        return this.sendVoipEvent(EventType.CallReplaces, body);
+        await this.terminate(CallParty.Local, CallErrorCode.Replaced, true);
+    }
+
+    /*
+     * Transfers this call to the target call, effectively 'joining' the
+     * two calls (so the remote parties on each call are connected together).
+     */
+    async transferToCall(transferTargetCall?: MatrixCall) {
+        const targetProfileInfo = await this.client.getProfileInfo(transferTargetCall.getOpponentMember().userId);
+        const transfereeProfileInfo = await this.client.getProfileInfo(this.getOpponentMember().userId);
+
+        const newCallId = genCallID();
+
+        const bodyToTransferTarget = {
+            // the replacements on each side have their own ID, and it's distinct from the
+            // ID of the new call (but we can use the same function to generate it)
+            replacement_id: genCallID(),
+            target_user: {
+                id: this.getOpponentMember().userId,
+                display_name: transfereeProfileInfo.display_name,
+                avatar_url: transfereeProfileInfo.avatar_url,
+            },
+            await_call: newCallId,
+        } as MCallReplacesEvent;
+
+        await transferTargetCall.sendVoipEvent(EventType.CallReplaces, bodyToTransferTarget);
+
+        const bodyToTransferee = {
+            replacement_id: genCallID(),
+            target_user: {
+                id: transferTargetCall.getOpponentMember().userId,
+                display_name: targetProfileInfo.display_name,
+                avatar_url: targetProfileInfo.avatar_url,
+            },
+            create_call: newCallId,
+        } as MCallReplacesEvent;
+
+        await this.sendVoipEvent(EventType.CallReplaces, bodyToTransferee);
+
+        await this.terminate(CallParty.Local, CallErrorCode.Replaced, true);
+        await transferTargetCall.terminate(CallParty.Local, CallErrorCode.Replaced, true);
    }

    private async terminate(hangupParty: CallParty, hangupReason: CallErrorCode, shouldEmit: boolean) {
@@ -1722,6 +1800,8 @@ export class MatrixCall extends EventEmitter {
        // I choo-choo-choose you
        const msg = ev.getContent();

+        logger.debug(`Choosing party ID ${msg.party_id} for call ID ${this.callId}`);
+
        this.opponentVersion = msg.version;
        if (this.opponentVersion === 0) {
            // set to null to indicate that we've chosen an opponent, but because
@@ -1735,30 +1815,32 @@ export class MatrixCall extends EventEmitter {
        }
        this.opponentCaps = msg.capabilities || {};
        this.opponentMember = ev.sender;
+    }

+    private async addBufferedIceCandidates() {
        const bufferedCands = this.remoteCandidateBuffer.get(this.opponentPartyId);
        if (bufferedCands) {
            logger.info(`Adding ${bufferedCands.length} buffered candidates for opponent ${this.opponentPartyId}`);
-            this.addIceCandidates(bufferedCands);
+            await this.addIceCandidates(bufferedCands);
        }
        this.remoteCandidateBuffer = null;
    }

-    private addIceCandidates(cands: RTCIceCandidate[]) {
+    private async addIceCandidates(cands: RTCIceCandidate[]) {
        for (const cand of cands) {
            if (
                (cand.sdpMid === null || cand.sdpMid === undefined) &&
                (cand.sdpMLineIndex === null || cand.sdpMLineIndex === undefined)
            ) {
                logger.debug("Ignoring remote ICE candidate with no sdpMid or sdpMLineIndex");
-                return;
+                continue;
            }
-            logger.debug("Got remote ICE " + cand.sdpMid + " candidate: " + cand.candidate);
+            logger.debug("Call " + this.callId + " got remote ICE " + cand.sdpMid + " candidate: " + cand.candidate);
            try {
-                this.peerConn.addIceCandidate(cand);
+                await this.peerConn.addIceCandidate(cand);
            } catch (err) {
                if (!this.ignoreOffer) {
-                    logger.info("Failed to add remore ICE candidate", err);
+                    logger.info("Failed to add remote ICE candidate", err);
                }
            }
        }
@@ -1854,6 +1936,9 @@ export function setAudioInput(deviceId: string) { audioInput = deviceId; }
 export function setVideoInput(deviceId: string) { videoInput = deviceId; }

 /**
+ * DEPRECATED
+ * Use client.createCall()
+ *
 * Create a new Matrix call for the browser.
 * @param {MatrixClient} client The client instance to use.
 * @param {string} roomId The room the call is in.
@@ -87,7 +87,11 @@ export class CallEventHandler {

    private onEvent = (event: MatrixEvent) => {
        // any call events or ones that might be once they're decrypted
-        if (event.getType().indexOf("m.call.") === 0 || event.isBeingDecrypted()) {
+        if (
+            event.getType().indexOf("m.call.") === 0 ||
+            event.getType().indexOf("org.matrix.call.") === 0
+            || event.isBeingDecrypted()
+        ) {
            // queue up for processing once all events from this sync have been
            // processed (see above).
            this.callEventBuffer.push(event);
@@ -271,6 +275,18 @@ export class CallEventHandler {
            }

            call.onNegotiateReceived(event);
+        } else if (
+            event.getType() === EventType.CallAssertedIdentity ||
+            event.getType() === EventType.CallAssertedIdentityPrefix
+        ) {
+            if (!call) return;
+
+            if (event.getContent().party_id === call.ourPartyId) {
+                // Ignore remote echo (not that we send asserted identity, but still...)
+                return;
+            }
+
+            call.onAssertedIdentityReceived(event);
        }
    }
 }
@@ -32,6 +32,7 @@ export interface MCallReplacesEvent {
    replacement_id: string;
    target_user: MCallReplacesTarget;
    create_call: string;
+    await_call: string;
    target_room: string;
 }
 /* eslint-enable camelcase */
Author	SHA1	Message	Date
RiotRobot	4e967c979c	v10.1.0-rc.1	2021-05-04 15:37:55 +01:00
RiotRobot	62a34848c7	Prepare changelog for v10.1.0-rc.1	2021-05-04 15:37:54 +01:00
Travis Ralston	01fe6cc542	Merge pull request #1681 from matrix-org/revert-1678-travis/event-logging Revert "Raise logging dramatically to chase pending event errors"	2021-05-02 19:11:06 -06:00
Travis Ralston	3fdc25777d	Revert "Raise logging dramatically to chase pending event errors"	2021-05-02 19:10:47 -06:00
J. Ryan Stinnett	dc64c34ccb	Merge pull request #1677 from matrix-org/jryans/coverage Add test coverage collection script	2021-04-28 17:18:07 +01:00
Travis Ralston	0bf50659ab	Merge pull request #1678 from matrix-org/travis/event-logging Raise logging dramatically to chase pending event errors	2021-04-28 09:30:04 -06:00
Travis Ralston	ec26b16ddf	Raise logging dramatically to chase pending event errors For https://github.com/vector-im/element-web/issues/17090 and similar issues This logging is expected to exist no longer than a day.	2021-04-28 09:24:19 -06:00
J. Ryan Stinnett	a044b74a1d	Add test coverage collection script This makes it clear to how collect basic test coverage when desired.	2021-04-28 14:17:08 +01:00
J. Ryan Stinnett	1e7a1dce90	Move Jest options into config block	2021-04-28 12:58:39 +01:00
David Baker	1bba2bc0ed	Merge pull request #1674 from matrix-org/dbkr/asserted_identity Support MSC3086 asserted identity	2021-04-28 09:47:30 +01:00
RiotRobot	b911a890cf	Add breaking notice	2021-04-26 18:03:19 +01:00
RiotRobot	c8f69c0b79	Resetting package fields for development	2021-04-26 17:37:06 +01:00
RiotRobot	8a6248f120	Merge branch 'master' into develop	2021-04-26 17:37:06 +01:00
RiotRobot	340fa6c63e	v10.0.0	2021-04-26 17:34:17 +01:00
RiotRobot	1177bf39a2	Prepare changelog for v10.0.0	2021-04-26 17:34:16 +01:00
David Baker	4a51ac7a74	Move createNewMatrixCall to the client object So we can mock it out it tests (and also I'm not sure why it was like this in the first place: we passed the client in anyway...) Deprecate createNewMatrixCall	2021-04-23 14:36:56 +01:00
J. Ryan Stinnett	6099efe41a	Merge pull request #1670 from timokoesters/fix-undefined-results Fix `/search` with no results field work again	2021-04-23 13:02:52 +01:00
Germain	4254d595fc	Merge pull request #1672 from hannojg/patch-5	2021-04-22 09:27:22 +01:00
Timo Kösters	069ca4a89d	fix: make /search with no results field work again	2021-04-21 22:56:36 +02:00
RiotRobot	e3ba08fbbc	v10.0.0-rc.1	2021-04-21 16:40:23 +01:00
RiotRobot	dd84e51161	Prepare changelog for v10.0.0-rc.1	2021-04-21 16:40:22 +01:00
David Baker	bca8568d64	missing semicolon	2021-04-20 12:58:33 +01:00
David Baker	5407717534	Assert event emitted	2021-04-20 12:57:11 +01:00
David Baker	74ef760591	Tests: They find bugs	2021-04-20 12:48:54 +01:00
Germain	b435b582bd	Merge pull request #1675 from matrix-org/gsouquet-powerlevels-perf Restrict event emit for room members that had power levels changed	2021-04-20 11:57:18 +01:00
Germain Souquet	d46021a05e	Restrict event emit for room members that had power levels changed	2021-04-20 11:22:16 +01:00
David Baker	1b31d0622e	Unit test for asserted identity messages	2021-04-20 11:08:06 +01:00
Michael Telatynski	68206a6e19	Merge pull request #1669 from hannojg/patch-3 Fix sync with misconfigured push rules	2021-04-20 08:57:16 +01:00
David Baker	56797948af	lint	2021-04-19 20:36:00 +01:00
David Baker	c0af2f25a1	Support MSC3086 asserted identity	2021-04-19 20:28:42 +01:00
Hanno J. Gödecke	dc12b1df00	feat: room.getMembers Signed-off-by: Hanno Gödecke <hgoedecke@cuvent.com>	2021-04-18 16:01:51 +02:00
Hanno J. Gödecke	b13f5aebfd	lint	2021-04-17 09:42:44 +02:00
Hanno J. Gödecke	338301bb5d	fix: failure during sync	2021-04-17 09:34:31 +02:00
Hubert Chathi	cbe9b59222	Merge pull request #1665 from uhoreg/dehydrated_device_missing_await Add missing await	2021-04-14 10:47:09 -04:00
Hubert Chathi	276b52f0fe	add missing await	2021-04-14 10:29:39 -04:00
J. Ryan Stinnett	09fac77ce0	Merge pull request #1642 from matrix-org/jryans/rework-linting Migrate to `eslint-plugin-matrix-org`	2021-04-13 11:12:39 +01:00
J. Ryan Stinnett	102704e91a	Migrate to `eslint-plugin-matrix-org` This migrates to the new plugin form of our custom ESLint configs. As part of this, some packages are de-duplicated, configs streamlined, etc.	2021-04-13 11:00:41 +01:00
Michael Telatynski	c5fb351baa	Merge pull request #1664 from matrix-org/t3chguy/fix/8665 Add missing event type enum for key verification done	2021-04-13 10:05:00 +01:00
Michael Telatynski	98f8d4414d	Add missing event type enum for key verification done	2021-04-13 09:41:53 +01:00
Germain	1dddcd4925	Merge pull request #1663 from matrix-org/gsouquet-timeline-jumpiness	2021-04-12 15:00:49 +01:00
Germain Souquet	2666a271a5	fix tests when pendingEventsList does not exist	2021-04-12 14:51:45 +01:00
RiotRobot	e277de6e3d	Resetting package fields for development	2021-04-12 14:42:29 +01:00
RiotRobot	daa17b3287	Merge branch 'master' into develop	2021-04-12 14:42:29 +01:00
RiotRobot	c7f887131e	v9.11.0	2021-04-12 14:39:33 +01:00
RiotRobot	58546b80d0	Prepare changelog for v9.11.0	2021-04-12 14:39:32 +01:00
Germain Souquet	466f749b71	fix typo	2021-04-12 14:38:27 +01:00
Germain Souquet	4c2a83c470	Add explanation for events persistence	2021-04-12 14:29:10 +01:00
Germain Souquet	d534ab18c7	fix event filtering logic	2021-04-12 13:07:57 +01:00
Germain Souquet	64aaed833b	Only persist encrypted events for encrypted rooms	2021-04-12 12:53:27 +01:00
Germain Souquet	2f05be599c	undo changes to event#toJSON and persist encrypted events	2021-04-12 12:26:27 +01:00
Germain Souquet	7371f8dd3a	Persist txnId to ensure idempotency	2021-04-12 09:55:01 +01:00
Germain Souquet	79aefe9707	Fix timeline jumpiness by setting correct txnId	2021-04-12 09:37:19 +01:00
Michael Telatynski	6bc80577ee	Merge pull request #1661 from janpawellek/janpawellek-fix-addEventListener Fix calling addEventListener if it does not exist	2021-04-12 09:15:19 +01:00
Germain	837764190f	Merge pull request #1655 from matrix-org/gsouquet-persist-unsent-messages	2021-04-09 17:48:01 +01:00
Germain Souquet	61948d70e3	Merge branch 'develop' into gsouquet-persist-unsent-messages	2021-04-09 17:05:19 +01:00
Jan Pawellek	9fb0385694	Fix calling addEventListener if it does not exist Some platforms (e.g. React Native) register global.window, but do not have global.window.addEventListener. In this case, this function should not be called.	2021-04-09 10:18:47 +02:00
RiotRobot	1c6459fe65	v9.11.0-rc.1	2021-04-07 12:55:25 +01:00
RiotRobot	adaeb42416	Prepare changelog for v9.11.0-rc.1	2021-04-07 12:55:24 +01:00
J. Ryan Stinnett	f1e1daa194	Merge pull request #1657 from matrix-org/jryans/cs-keys-test Only try to cache private keys we know exist	2021-04-06 10:09:04 +01:00
J. Ryan Stinnett	401e89ef78	Only try to cache private keys we know exist This tweaks https://github.com/matrix-org/matrix-js-sdk/pull/1649 to only try caching private keys locally once we've confirmed they exist first. This is most likely only an issue in tests, where we sometimes create only some but not all keys.	2021-04-06 09:49:20 +01:00
Travis Ralston	59e0bd467c	Merge pull request #1654 from SimonBrandner/terminate-screen-share Properly terminate screen-share calls if NoUserMedia	2021-04-05 10:55:02 -06:00
David Baker	3820c15ecf	Merge pull request #1652 from matrix-org/dbkr/attended_transfer Attended transfer	2021-04-01 17:34:18 +01:00
Germain Souquet	26ef33e4f3	No this assign	2021-04-01 17:29:21 +01:00
Germain Souquet	0534a4ed1b	prevent removePendingEvent being called when not in detached mode	2021-04-01 17:23:55 +01:00
Germain Souquet	f29a24a915	specify TestClient when testing room model	2021-04-01 15:22:13 +01:00
Germain Souquet	cecbcd941e	Persist unsent messages for subsequent sessions	2021-04-01 10:59:16 +01:00
David Baker	6be99d6397	Terminate the other call too	2021-03-30 12:13:28 +01:00
J. Ryan Stinnett	4e5947af51	Merge pull request #1653 from matrix-org/jryans/cancel-security-key Remove catch handlers in private key retrieval	2021-03-29 17:58:07 +01:00
RiotRobot	4204b2170a	Resetting package fields for development	2021-03-29 13:28:09 +01:00
RiotRobot	0a5ad489b6	Merge branch 'master' into develop	2021-03-29 13:28:08 +01:00
RiotRobot	5de34a5c99	v9.10.0	2021-03-29 13:25:27 +01:00
RiotRobot	08da6b8800	Prepare changelog for v9.10.0	2021-03-29 13:25:27 +01:00
Šimon Brandner	02b283be78	Properly terminate screenshare calls if NoUserMedia Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-03-27 09:13:44 +01:00
J. Ryan Stinnett	10c49c0fd1	Remove catch handlers in private key retrieval This removes some catch blocks originally added by https://github.com/matrix-org/matrix-js-sdk/pull/1472 so that higher level operations can handle them as needed. Part of https://github.com/vector-im/element-web/issues/15584	2021-03-26 17:57:23 +00:00
David Baker	9ecc0f5d95	Terminate calls once we've replaced them	2021-03-26 13:52:23 +00:00
Travis Ralston	972b59b99e	Merge pull request #1651 from DantrazTrev/CallErrorFix Fixed the media fail error on caller's side	2021-03-25 19:05:36 -06:00
David Baker	34bb05bd88	WIP attended transfer	2021-03-25 19:57:20 +00:00
Hubert Chathi	37fb21f726	Merge pull request #1640 from uhoreg/room-history-key-sharing2 Add function to share megolm keys for historical messages.	2021-03-25 14:18:12 -04:00
Ayush PS	b42efa4a07	Fixed lint errors	2021-03-25 23:38:18 +05:30
Ayush PS	20b20738a7	Fixed a slight error back to orignal in ScreenShareCall	2021-03-25 23:02:44 +05:30
Ayush PS	b28a191c4e	Fixed the media fail error on caller's side	2021-03-25 22:43:18 +05:30
Hubert Chathi	f92b620434	Merge branch 'develop' into room-history-key-sharing2	2021-03-25 12:24:42 -04:00
RiotRobot	ae6e2cca27	v9.10.0-rc.1	2021-03-25 12:06:34 +00:00
RiotRobot	bd920eef1f	Prepare changelog for v9.10.0-rc.1	2021-03-25 12:06:34 +00:00
J. Ryan Stinnett	bf25cb68da	Merge pull request #1649 from matrix-org/jryans/get-keys-bootstrap-only Cache cross-signing private keys if needed on bootstrap	2021-03-24 15:56:15 +00:00
J. Ryan Stinnett	0b063f6b8b	Cache cross-signing private keys if needed on bootstrap This is a revised version of https://github.com/matrix-org/matrix-js-sdk/pull/1472 which was previously reverted for causing security prompts to appear on device list sync. In this version, we only allow private key requests (which are likely to trigger user dialogs) if we are coming from the bootstrap path. This allows sessions that have already synced cross-signing public keys but never got the private keys for some reason to make forward progress when e.g. the user triggers bootstrap from security settings.	2021-03-24 11:48:45 +00:00
Travis Ralston	ed6d4e5f6c	Merge pull request #1647 from SimonBrandner/dont-send-hangup Don't send m.call.hangup if m.call.invite wasn't sent either	2021-03-22 00:42:04 -06:00
Travis Ralston	accfa325b5	Merge pull request #1641 from NicolaiSoeborg/fix-registerGuest docs: registerGuest()	2021-03-21 20:37:49 -06:00
Šimon Brandner	b6ef8d95cd	Don't send hangup if invite wasn't sent Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-03-21 21:29:00 +01:00
Travis Ralston	c1144e3810	Merge pull request #1639 from Johennes/feature/chunk-device-keys Download device keys in chunks of 250	2021-03-18 13:17:15 -06:00
Johannes Marbach	8663fd402b	Download device keys in chunks of 250 Depending on the number of users in the request, the server might overload. To prevent this, the download is broken into chunks of 250 users each. Additionally, no more than 3 requests are kicked off at the same time to avoid running into rate limiting. Responses are processed once all chunks have been downloaded. Fixes: #1619 Signed-off-by: Johannes Marbach <n0-0ne+github@mailbox.org>	2021-03-17 20:56:25 +01:00
David Baker	f34052fd31	Merge pull request #1646 from matrix-org/dbkr/more_call_fixes More VoIP connectivity fixes	2021-03-17 15:00:09 +00:00
David Baker	27d75a269f	unintentional comment	2021-03-16 19:18:45 +00:00
David Baker	d208a7fc5f	Remove unintentionally committed stuff	2021-03-16 19:17:04 +00:00
David Baker	702e16e3df	More VoIP connectivity fixes * Don't ignore other candidates when we see a null one (continue rather than return) * await on addICECandidate() * Don't add ice candidates until we've set a remote description * More & better logging	2021-03-16 19:13:03 +00:00
Hubert Chathi	6381018658	add jsdoc and implementation for memory crypto store	2021-03-16 13:52:05 -04:00
Travis Ralston	12050b14f0	Merge pull request #1644 from SimonBrandner/fix-optional Make selectDesktopCapturerSource param optional	2021-03-15 21:12:03 -06:00
Hubert Chathi	1c191b2278	use new terminology and field name from MSC	2021-03-15 22:49:43 -04:00
Nicolai Søborg	2d4a4f1736	docs: registerGuest	2021-03-15 22:46:43 +00:00
RiotRobot	cd38fb9b4c	Resetting package fields for development	2021-03-15 14:34:56 +00:00
RiotRobot	7941b16ec4	Merge branch 'master' into develop	2021-03-15 14:34:56 +00:00
Šimon Brandner	56ea4b8741	Make selectDesktopCapturerSource param optional Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>	2021-03-13 15:03:36 +01:00
Hubert Chathi	a489691151	various fixes	2021-03-11 17:30:05 -05:00
Nicolai Søborg	6dabfcda6f	setGuest(true) when registerGuest() Signed-off-by: Nicolai Søborg <git@xn--sb-lka.org>	2021-03-11 22:39:51 +01:00
J. Ryan Stinnett	0b7b35f800	Merge pull request #1632 from matrix-org/matthew/rework-cross-signing-login Expose APIs needed for reworked cross-signing login flow	2021-03-11 12:54:18 +00:00
Hubert Chathi	0bfcb5071d	fix test, lint	2021-03-10 20:04:34 -05:00
Hubert Chathi	ceb162eb01	initial work on room history key sharing, take 2	2021-03-10 19:51:22 -05:00
Matthew Hodgson	9fb2fbaeec	factor out getDehydratedDevice	2021-03-09 00:09:22 +00:00
Matthew Hodgson	977682d37f	fix lint	2021-03-08 09:24:25 +00:00
Matthew Hodgson	0bafe263d7	fix lint	2021-03-08 05:05:14 +00:00
Matthew Hodgson	1a8fced80e	Merge branch 'develop' into matthew/rework-cross-signing-login	2021-03-08 04:59:40 +00:00
Matthew Hodgson	1c4d0b5e99	expose getDevice API	2021-03-08 04:59:29 +00:00
Matthew Hodgson	844a2b457c	expose getDehydratedDevice API	2021-03-08 04:59:19 +00:00
Matthew Hodgson	ccf06f2216	don't cancel ourselves when selecting a self-verification partner	2021-03-08 04:58:55 +00:00