v12.5.0

Tests for key sharing security fix

CHANGELOG.md

@@ -1,18 +1,59 @@
-Changes in [12.3.0-rc.2](https://github.com/vector-im/element-desktop/releases/tag/v12.3.0-rc.2) (2021-07-12)
-=============================================================================================================
+Changes in [12.5.0](https://github.com/vector-im/element-desktop/releases/tag/v12.5.0) (2021-09-14)
+===================================================================================================
+
+## ✨ Features
+ * [Release] Exclude opt-in Element performance metrics from encryption ([\#1901](https://github.com/matrix-org/matrix-js-sdk/pull/1901)).
+ * Give `MatrixCall` the capability to emit `LengthChanged` events ([\#1873](https://github.com/matrix-org/matrix-js-sdk/pull/1873)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Improve browser example ([\#1875](https://github.com/matrix-org/matrix-js-sdk/pull/1875)). Contributed by [psrpinto](https://github.com/psrpinto).
+ * Give `CallFeed` the capability to emit on volume changes ([\#1865](https://github.com/matrix-org/matrix-js-sdk/pull/1865)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
- * Fix the types in shipped package ([\#1842](https://github.com/matrix-org/matrix-js-sdk/pull/1842)). Fixes vector-im/element-web#18503 and vector-im/element-web#18503.
+ * Fix verification request cancellation ([\#1871](https://github.com/matrix-org/matrix-js-sdk/pull/1871)).
 
-Changes in [12.3.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v12.3.0-rc.1) (2021-07-11)
+Changes in [12.5.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v12.5.0-rc.1) (2021-09-07)
 =============================================================================================================
 
+## ✨ Features
+ * Give `MatrixCall` the capability to emit `LengthChanged` events ([\#1873](https://github.com/matrix-org/matrix-js-sdk/pull/1873)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Improve browser example ([\#1875](https://github.com/matrix-org/matrix-js-sdk/pull/1875)). Contributed by [psrpinto](https://github.com/psrpinto).
+ * Give `CallFeed` the capability to emit on volume changes ([\#1865](https://github.com/matrix-org/matrix-js-sdk/pull/1865)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+## 🐛 Bug Fixes
+ * Fix verification request cancellation ([\#1871](https://github.com/matrix-org/matrix-js-sdk/pull/1871)).
+
+Changes in [12.4.0](https://github.com/vector-im/element-desktop/releases/tag/v12.4.0) (2021-08-31)
+===================================================================================================
+
+## 🦖 Deprecations
+ * Deprecate groups APIs. Groups are no longer supported, only Synapse has support. They are being replaced by Spaces which build off of Rooms and are far more flexible. ([\#1792](https://github.com/matrix-org/matrix-js-sdk/pull/1792)).
+
+## ✨ Features
+ * Add method for including extra fields when uploading to a tree space ([\#1850](https://github.com/matrix-org/matrix-js-sdk/pull/1850)).
+
+## 🐛 Bug Fixes
+ * Fix broken voice calls, no ringing and broken call notifications ([\#1858](https://github.com/matrix-org/matrix-js-sdk/pull/1858)). Fixes vector-im/element-web#18578 vector-im/element-web#18538 and vector-im/element-web#18578. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Revert "Fix glare related regressions" ([\#1857](https://github.com/matrix-org/matrix-js-sdk/pull/1857)).
+ * Fix glare related regressions ([\#1851](https://github.com/matrix-org/matrix-js-sdk/pull/1851)). Fixes vector-im/element-web#18538 and vector-im/element-web#18538. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix temporary call messages being handled without call  ([\#1834](https://github.com/matrix-org/matrix-js-sdk/pull/1834)). Contributed by [Palid](https://github.com/Palid).
+ * Fix conditional on returning file tree spaces ([\#1841](https://github.com/matrix-org/matrix-js-sdk/pull/1841)).
+
+Changes in [12.3.1](https://github.com/vector-im/element-desktop/releases/tag/v12.3.1) (2021-08-17)
+===================================================================================================
+
+## 🐛 Bug Fixes
+ * Fix multiple VoIP regressions ([\#1860](https://github.com/matrix-org/matrix-js-sdk/pull/1860)).
+
+Changes in [12.3.0](https://github.com/vector-im/element-desktop/releases/tag/v12.3.0) (2021-08-16)
+===================================================================================================
+
 ## ✨ Features
  * Support for MSC3291: Muting in VoIP calls ([\#1812](https://github.com/matrix-org/matrix-js-sdk/pull/1812)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
  * Support for screen-sharing using multi-stream VoIP (MSC3077) ([\#1685](https://github.com/matrix-org/matrix-js-sdk/pull/1685)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
  * Handle DTMF support ([\#1813](https://github.com/matrix-org/matrix-js-sdk/pull/1813)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
+ * [Release] Fix glare related regressions ([\#1854](https://github.com/matrix-org/matrix-js-sdk/pull/1854)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix the types in shipped package ([\#1842](https://github.com/matrix-org/matrix-js-sdk/pull/1842)). Fixes vector-im/element-web#18503 and vector-im/element-web#18503.
  * Fix error on turning off screensharing ([\#1833](https://github.com/matrix-org/matrix-js-sdk/pull/1833)). Fixes vector-im/element-web#18449. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
  * Fix blank profile in join events ([\#1837](https://github.com/matrix-org/matrix-js-sdk/pull/1837)). Fixes vector-im/element-web#18321.
  * fix TURN by fixing regression preventing multiple ICE candidates from sending. ([\#1838](https://github.com/matrix-org/matrix-js-sdk/pull/1838)).
@@ -20,7 +61,7 @@ Changes in [12.3.0-rc.1](https://github.com/vector-im/element-desktop/releases/t
  * Apply hidden char check to rawDisplayName too ([\#1816](https://github.com/matrix-org/matrix-js-sdk/pull/1816)).
  * Only clear bit 63 when we create the IV ([\#1819](https://github.com/matrix-org/matrix-js-sdk/pull/1819)).
 
-Changes in [12.2.0](https://github.com/vector-im/element-desktop/releases/tag/v12.2.0) (2021-07-02)
+Changes in [12.2.0](https://github.com/vector-im/element-desktop/releases/tag/v12.2.0) (2021-08-02)
 ===================================================================================================
 
 ## ✨ Features

examples/browser/browserTest.js

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

examples/browser/index.html

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "matrix-js-sdk",
-  "version": "12.3.0-rc.2",
+  "version": "12.5.0",
   "description": "Matrix Client-Server SDK for Javascript",
   "scripts": {
     "prepublishOnly": "yarn build",
@@ -81,7 +81,7 @@
     "@types/request": "^2.48.5",
     "@typescript-eslint/eslint-plugin": "^4.17.0",
     "@typescript-eslint/parser": "^4.17.0",
-    "allchange": "^0.0.1",
+    "allchange": "^1.0.2",
     "babel-jest": "^26.6.3",
     "babelify": "^10.0.0",
     "better-docs": "^2.4.0-beta.9",

release.sh

@@ -191,7 +191,10 @@ git commit package.json $pkglock -m "$tag"
 # figure out if we should be signing this release
 signing_id=
 if [ -f release_config.yaml ]; then
-    signing_id=`cat release_config.yaml | python -c "import yaml; import sys; print yaml.load(sys.stdin)['signing_id']"`
+    result=`cat release_config.yaml | python -c "import yaml; import sys; print yaml.load(sys.stdin)['signing_id']" 2> /dev/null || true`
+    if [ "$?" -eq 0 ]; then
+        signing_id=$result
+    fi
 fi
 
 

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

@@ -256,97 +256,145 @@ describe("MegolmDecryption", function() {
             });
         });
 
-        it("re-uses sessions for sequential messages", async function() {
-            mockCrypto.backupManager = {
-                backupGroupSession: () => {},
-            };
-            const mockStorage = new MockStorageApi();
-            const cryptoStore = new MemoryCryptoStore(mockStorage);
+        describe("session reuse and key reshares", () => {
+            let megolmEncryption;
+            let aliceDeviceInfo;
+            let mockRoom;
+            let olmDevice;
 
-            const olmDevice = new OlmDevice(cryptoStore);
-            olmDevice.verifySignature = jest.fn();
-            await olmDevice.init();
+            beforeEach(async () => {
+                mockCrypto.backupManager = {
+                    backupGroupSession: () => {},
+                };
+                const mockStorage = new MockStorageApi();
+                const cryptoStore = new MemoryCryptoStore(mockStorage);
 
-            mockBaseApis.claimOneTimeKeys = jest.fn().mockReturnValue(Promise.resolve({
-                one_time_keys: {
-                    '@alice:home.server': {
-                        aliceDevice: {
-                            'signed_curve25519:flooble': {
-                                key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
-                                signatures: {
-                                    '@alice:home.server': {
-                                        'ed25519:aliceDevice': 'totally valid',
+                olmDevice = new OlmDevice(cryptoStore);
+                olmDevice.verifySignature = jest.fn();
+                await olmDevice.init();
+
+                mockBaseApis.claimOneTimeKeys = jest.fn().mockReturnValue(Promise.resolve({
+                    one_time_keys: {
+                        '@alice:home.server': {
+                            aliceDevice: {
+                                'signed_curve25519:flooble': {
+                                    key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
+                                    signatures: {
+                                        '@alice:home.server': {
+                                            'ed25519:aliceDevice': 'totally valid',
+                                        },
                                     },
                                 },
                             },
                         },
                     },
-                },
-            }));
-            mockBaseApis.sendToDevice = jest.fn().mockResolvedValue(undefined);
+                }));
+                mockBaseApis.sendToDevice = jest.fn().mockResolvedValue(undefined);
 
-            mockCrypto.downloadKeys.mockReturnValue(Promise.resolve({
-                '@alice:home.server': {
-                    aliceDevice: {
-                        deviceId: 'aliceDevice',
-                        isBlocked: jest.fn().mockReturnValue(false),
-                        isUnverified: jest.fn().mockReturnValue(false),
-                        getIdentityKey: jest.fn().mockReturnValue(
-                            'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
-                        ),
-                        getFingerprint: jest.fn().mockReturnValue(''),
+                aliceDeviceInfo = {
+                    deviceId: 'aliceDevice',
+                    isBlocked: jest.fn().mockReturnValue(false),
+                    isUnverified: jest.fn().mockReturnValue(false),
+                    getIdentityKey: jest.fn().mockReturnValue(
+                        'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
+                    ),
+                    getFingerprint: jest.fn().mockReturnValue(''),
+                };
+
+                mockCrypto.downloadKeys.mockReturnValue(Promise.resolve({
+                    '@alice:home.server': {
+                        aliceDevice: aliceDeviceInfo,
                     },
-                },
-            }));
+                }));
 
-            mockCrypto.checkDeviceTrust.mockReturnValue({
-                isVerified: () => false,
+                mockCrypto.checkDeviceTrust.mockReturnValue({
+                    isVerified: () => false,
+                });
+
+                megolmEncryption = new MegolmEncryption({
+                    userId: '@user:id',
+                    crypto: mockCrypto,
+                    olmDevice: olmDevice,
+                    baseApis: mockBaseApis,
+                    roomId: ROOM_ID,
+                    config: {
+                        rotation_period_ms: 9999999999999,
+                    },
+                });
+                mockRoom = {
+                    getEncryptionTargetMembers: jest.fn().mockReturnValue(
+                        [{ userId: "@alice:home.server" }],
+                    ),
+                    getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
+                };
             });
 
-            const megolmEncryption = new MegolmEncryption({
-                userId: '@user:id',
-                crypto: mockCrypto,
-                olmDevice: olmDevice,
-                baseApis: mockBaseApis,
-                roomId: ROOM_ID,
-                config: {
-                    rotation_period_ms: 9999999999999,
-                },
-            });
-            const mockRoom = {
-                getEncryptionTargetMembers: jest.fn().mockReturnValue(
-                    [{ userId: "@alice:home.server" }],
-                ),
-                getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
-            };
-            const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                body: "Some text",
-            });
-            expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
+            it("re-uses sessions for sequential messages", async function() {
+                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some text",
+                });
+                expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
 
-            // this should have claimed a key for alice as it's starting a new session
-            expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-            );
-            expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
-                ['@alice:home.server'], false,
-            );
-            expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
-            expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-            );
+                // this should have claimed a key for alice as it's starting a new session
+                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
+                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
+                );
+                expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
+                    ['@alice:home.server'], false,
+                );
+                expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
+                expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
+                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
+                );
 
-            mockBaseApis.claimOneTimeKeys.mockReset();
+                mockBaseApis.claimOneTimeKeys.mockReset();
 
-            const ct2 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
-                body: "Some more text",
+                const ct2 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some more text",
+                });
+
+                // this should *not* have claimed a key as it should be using the same session
+                expect(mockBaseApis.claimOneTimeKeys).not.toHaveBeenCalled();
+
+                // likewise they should show the same session ID
+                expect(ct2.session_id).toEqual(ct1.session_id);
             });
 
-            // this should *not* have claimed a key as it should be using the same session
-            expect(mockBaseApis.claimOneTimeKeys).not.toHaveBeenCalled();
+            it("re-shares keys to devices it's already sent to", async function() {
+                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some text",
+                });
 
-            // likewise they should show the same session ID
-            expect(ct2.session_id).toEqual(ct1.session_id);
+                mockBaseApis.sendToDevice.mockClear();
+                await megolmEncryption.reshareKeyWithDevice(
+                    olmDevice.deviceCurve25519Key,
+                    ct1.session_id,
+                    '@alice:home.server',
+                    aliceDeviceInfo,
+                );
+
+                expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
+            });
+
+            it("does not re-share keys to devices whose keys have changed", async function() {
+                const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
+                    body: "Some text",
+                });
+
+                aliceDeviceInfo.getIdentityKey = jest.fn().mockReturnValue(
+                    'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWI',
+                );
+
+                mockBaseApis.sendToDevice.mockClear();
+                await megolmEncryption.reshareKeyWithDevice(
+                    olmDevice.deviceCurve25519Key,
+                    ct1.session_id,
+                    '@alice:home.server',
+                    aliceDeviceInfo,
+                );
+
+                expect(mockBaseApis.sendToDevice).not.toHaveBeenCalled();
+            });
         });
     });
 

spec/unit/matrix-client.spec.js

@@ -237,6 +237,7 @@ describe("MatrixClient", function() {
     it("should get (unstable) file trees with valid state", async () => {
         const roomId = "!room:example.org";
         const mockRoom = {
+            getMyMembership: () => "join",
             currentState: {
                 getStateEvents: (eventType, stateKey) => {
                     if (eventType === EventType.RoomCreate) {
@@ -270,9 +271,33 @@ describe("MatrixClient", function() {
         expect(tree.room).toBe(mockRoom);
     });
 
+    it("should not get (unstable) file trees if not joined", async () => {
+        const roomId = "!room:example.org";
+        const mockRoom = {
+            getMyMembership: () => "leave", // "not join"
+        };
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return mockRoom;
+        };
+        const tree = client.unstableGetFileTreeSpace(roomId);
+        expect(tree).toBeFalsy();
+    });
+
+    it("should not get (unstable) file trees for unknown rooms", async () => {
+        const roomId = "!room:example.org";
+        client.getRoom = (getRoomId) => {
+            expect(getRoomId).toEqual(roomId);
+            return null; // imply unknown
+        };
+        const tree = client.unstableGetFileTreeSpace(roomId);
+        expect(tree).toBeFalsy();
+    });
+
     it("should not get (unstable) file trees with invalid create contents", async () => {
         const roomId = "!room:example.org";
         const mockRoom = {
+            getMyMembership: () => "join",
             currentState: {
                 getStateEvents: (eventType, stateKey) => {
                     if (eventType === EventType.RoomCreate) {
@@ -307,6 +332,7 @@ describe("MatrixClient", function() {
     it("should not get (unstable) file trees with invalid purpose/subtype contents", async () => {
         const roomId = "!room:example.org";
         const mockRoom = {
+            getMyMembership: () => "join",
             currentState: {
                 getStateEvents: (eventType, stateKey) => {
                     if (eventType === EventType.RoomCreate) {

src/@types/PushRules.ts

@@ -90,8 +90,9 @@ export interface ISenderNotificationPermissionCondition
     key: string;
 }
 
-export type PushRuleCondition = IPushRuleCondition<string>
-    | IEventMatchCondition
+// XXX: custom conditions are possible but always fail, and break the typescript discriminated union so ignore them here
+// IPushRuleCondition<Exclude<string, ConditionKind>> unfortunately does not resolve this at the time of writing.
+export type PushRuleCondition = IEventMatchCondition
     | IContainsDisplayNameCondition
     | IRoomMemberCountCondition
     | ISenderNotificationPermissionCondition;

src/@types/event.ts

@@ -168,6 +168,11 @@ export const UNSTABLE_ELEMENT_FUNCTIONAL_USERS = new UnstableValue(
     "io.element.functional_members",
     "io.element.functional_members");
 
+export const UNSTABLE_ELEMENT_REPLY_IN_THREAD = new UnstableValue(
+    "m.in_thread",
+    "io.element.in_thread",
+);
+
 export interface IEncryptedFile {
     url: string;
     mimetype?: string;

src/@types/global.d.ts

@@ -34,6 +34,7 @@ declare global {
 
     interface Window {
         electron?: Electron;
+        webkitAudioContext: typeof AudioContext;
     }
 
     interface Electron {

src/@types/partials.ts

@@ -55,12 +55,20 @@ export enum JoinRule {
      * @deprecated Reserved keyword. Should not be used. Not yet implemented.
      */
     Private = "private",
-    Knock = "knock", // MSC2403 - only valid inside experimental room versions at this time.
-    Restricted = "restricted", // MSC3083 - only valid inside experimental room versions at this time.
+    Knock = "knock",
+    Restricted = "restricted",
 }
 
 export enum RestrictedAllowType {
-    RoomMembership = "m.room_membership", // MSC3083 - only valid inside experimental room versions at this time.
+    RoomMembership = "m.room_membership",
+}
+
+export interface IJoinRuleEventContent {
+    join_rule: JoinRule; // eslint-disable-line camelcase
+    allow?: {
+        type: RestrictedAllowType;
+        room_id: string; // eslint-disable-line camelcase
+    }[];
 }
 
 export enum GuestAccess {

src/@types/spaces.ts

@@ -15,21 +15,26 @@ limitations under the License.
 */
 
 import { IPublicRoomsChunkRoom } from "../client";
+import { RoomType } from "./event";
+import { IStrippedState } from "../sync-accumulator";
 
 // Types relating to Rooms of type `m.space` and related APIs
 
 /* eslint-disable camelcase */
+/** @deprecated Use hierarchy instead where possible. */
 export interface ISpaceSummaryRoom extends IPublicRoomsChunkRoom {
     num_refs: number;
     room_type: string;
 }
 
+/** @deprecated Use hierarchy instead where possible. */
 export interface ISpaceSummaryEvent {
     room_id: string;
     event_id: string;
     origin_server_ts: number;
     type: string;
     state_key: string;
+    sender: string;
     content: {
         order?: string;
         suggested?: boolean;
@@ -37,4 +42,19 @@ export interface ISpaceSummaryEvent {
         via?: string[];
     };
 }
+
+export interface IHierarchyRelation extends IStrippedState {
+    room_id: string;
+    origin_server_ts: number;
+    content: {
+        order?: string;
+        suggested?: boolean;
+        via?: string[];
+    };
+}
+
+export interface IHierarchyRoom extends IPublicRoomsChunkRoom {
+    room_type?: RoomType | string;
+    children_state: IHierarchyRelation[];
+}
 /* eslint-enable camelcase */

src/client.ts

@@ -30,7 +30,7 @@ import * as utils from './utils';
 import { sleep } from './utils';
 import { Group } from "./models/group";
 import { Direction, EventTimeline } from "./models/event-timeline";
-import { PushAction, PushProcessor } from "./pushprocessor";
+import { IActionsObject, PushProcessor } from "./pushprocessor";
 import { AutoDiscovery } from "./autodiscovery";
 import * as olmlib from "./crypto/olmlib";
 import { decodeBase64, encodeBase64 } from "./crypto/olmlib";
@@ -140,7 +140,7 @@ import {
     SearchOrderBy,
 } from "./@types/search";
 import { ISynapseAdminDeactivateResponse, ISynapseAdminWhoisResponse } from "./@types/synapse";
-import { ISpaceSummaryEvent, ISpaceSummaryRoom } from "./@types/spaces";
+import { IHierarchyRoom, ISpaceSummaryEvent, ISpaceSummaryRoom } from "./@types/spaces";
 import { IPusher, IPusherRequest, IPushRules, PushRuleAction, PushRuleKind, RuleId } from "./@types/PushRules";
 import { IThreepid } from "./@types/threepids";
 import { CryptoStore } from "./crypto/store/base";
@@ -380,6 +380,11 @@ export interface IStartClientOpts {
      * This should be in the order of hours. Default: undefined.
      */
     clientWellKnownPollPeriod?: number;
+
+    /**
+     * @experimental
+     */
+    experimentalThreadSupport?: boolean;
 }
 
 export interface IStoredClientOpts extends IStartClientOpts {
@@ -521,7 +526,7 @@ interface IMessagesResponse {
     state: IStateEvent[];
 }
 
-interface IRequestTokenResponse {
+export interface IRequestTokenResponse {
     sid: string;
     submit_url?: string;
 }
@@ -600,7 +605,7 @@ interface IUserDirectoryResponse {
     limited: boolean;
 }
 
-interface IMyDevice {
+export interface IMyDevice {
     device_id: string;
     display_name?: string;
     last_seen_ip?: string;
@@ -2931,6 +2936,7 @@ export class MatrixClient extends EventEmitter {
      * has been emitted.
      * @param {string} groupId The group ID
      * @return {Group} The Group or null if the group is not known or there is no data store.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroup(groupId: string): Group {
         return this.store.getGroup(groupId);
@@ -2939,6 +2945,7 @@ export class MatrixClient extends EventEmitter {
     /**
      * Retrieve all known groups.
      * @return {Group[]} A list of groups, or an empty list if there is no data store.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroups(): Group[] {
         return this.store.getGroups();
@@ -4340,7 +4347,7 @@ export class MatrixClient extends EventEmitter {
      * @param {MatrixEvent} event The event to get push actions for.
      * @return {module:pushprocessor~PushAction} A dict of actions to perform.
      */
-    public getPushActionsForEvent(event: MatrixEvent): PushAction {
+    public getPushActionsForEvent(event: MatrixEvent): IActionsObject {
         if (!event.getPushActions()) {
             event.setPushActions(this.pushProcessor.actionsForEvent(event));
         }
@@ -5076,7 +5083,7 @@ export class MatrixClient extends EventEmitter {
         email: string,
         clientSecret: string,
         sendAttempt: number,
-        nextLink: string,
+        nextLink?: string,
     ): Promise<IRequestTokenResponse> {
         return this.requestTokenFromEndpoint(
             "/account/password/email/requestToken",
@@ -7973,14 +7980,15 @@ export class MatrixClient extends EventEmitter {
     }
 
     /**
-     * Fetches or paginates a summary of a space as defined by MSC2946
+     * Fetches or paginates a summary of a space as defined by an initial version of MSC2946
      * @param {string} roomId The ID of the space-room to use as the root of the summary.
      * @param {number?} maxRoomsPerSpace The maximum number of rooms to return per subspace.
      * @param {boolean?} suggestedOnly Whether to only return rooms with suggested=true.
      * @param {boolean?} autoJoinOnly Whether to only return rooms with auto_join=true.
      * @param {number?} limit The maximum number of rooms to return in total.
      * @param {string?} batch The opaque token to paginate a previous summary request.
-     * @returns {Promise} the response, with next_batch, rooms, events fields.
+     * @returns {Promise} the response, with next_token, rooms fields.
+     * @deprecated in favour of `getRoomHierarchy` due to the MSC changing paths.
      */
     public getSpaceSummary(
         roomId: string,
@@ -7989,10 +7997,7 @@ export class MatrixClient extends EventEmitter {
         autoJoinOnly?: boolean,
         limit?: number,
         batch?: string,
-    ): Promise<{
-        rooms: ISpaceSummaryRoom[];
-        events: ISpaceSummaryEvent[];
-    }> {
+    ): Promise<{rooms: ISpaceSummaryRoom[], events: ISpaceSummaryEvent[]}> {
         const path = utils.encodeUri("/rooms/$roomId/spaces", {
             $roomId: roomId,
         });
@@ -8008,6 +8013,60 @@ export class MatrixClient extends EventEmitter {
         });
     }
 
+    /**
+     * Fetches or paginates a room hierarchy as defined by MSC2946.
+     * Falls back gracefully to sourcing its data from `getSpaceSummary` if this API is not yet supported by the server.
+     * @param {string} roomId The ID of the space-room to use as the root of the summary.
+     * @param {number?} limit The maximum number of rooms to return per page.
+     * @param {number?} maxDepth The maximum depth in the tree from the root room to return.
+     * @param {boolean?} suggestedOnly Whether to only return rooms with suggested=true.
+     * @param {string?} fromToken The opaque token to paginate a previous request.
+     * @returns {Promise} the response, with next_batch & rooms fields.
+     */
+    public getRoomHierarchy(
+        roomId: string,
+        limit?: number,
+        maxDepth?: number,
+        suggestedOnly = false,
+        fromToken?: string,
+    ): Promise<{
+        rooms: IHierarchyRoom[];
+        next_batch?: string; // eslint-disable-line camelcase
+    }> {
+        const path = utils.encodeUri("/rooms/$roomId/hierarchy", {
+            $roomId: roomId,
+        });
+
+        return this.http.authedRequest(undefined, "GET", path, {
+            suggested_only: suggestedOnly,
+            max_depth: maxDepth,
+            from: fromToken,
+            limit,
+        }, undefined, {
+            prefix: "/_matrix/client/unstable/org.matrix.msc2946",
+        }).catch(e => {
+            if (e.errcode === "M_UNRECOGNIZED") {
+                // fall back to the older space summary API as it exposes the same data just in a different shape.
+                return this.getSpaceSummary(roomId, undefined, suggestedOnly, undefined, limit)
+                    .then(({ rooms, events }) => {
+                        // Translate response from `/spaces` to that we expect in this API.
+                        const roomMap = new Map(rooms.map(r => {
+                            return [r.room_id, <IHierarchyRoom>{ ...r, children_state: [] }];
+                        }));
+                        events.forEach(e => {
+                            roomMap.get(e.room_id)?.children_state.push(e);
+                        });
+
+                        return {
+                            rooms: Array.from(roomMap.values()),
+                        };
+                    });
+            }
+
+            throw e;
+        });
+    }
+
     /**
      * Creates a new file tree space with the given name. The client will pick
      * defaults for how it expects to be able to support the remaining API offered
@@ -8060,7 +8119,7 @@ export class MatrixClient extends EventEmitter {
      */
     public unstableGetFileTreeSpace(roomId: string): MSC3089TreeSpace {
         const room = this.getRoom(roomId);
-        if (!room) return null;
+        if (room?.getMyMembership() !== 'join') return null;
 
         const createEvent = room.currentState.getStateEvents(EventType.RoomCreate, "");
         const purposeEvent = room.currentState.getStateEvents(
@@ -8085,6 +8144,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} groupId
      * @return {Promise} Resolves: Group summary object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroupSummary(groupId: string): Promise<any> {
         const path = utils.encodeUri("/groups/$groupId/summary", { $groupId: groupId });
@@ -8095,6 +8155,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} groupId
      * @return {Promise} Resolves: Group profile object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroupProfile(groupId: string): Promise<any> {
         const path = utils.encodeUri("/groups/$groupId/profile", { $groupId: groupId });
@@ -8110,6 +8171,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string=} profile.long_description A longer HTML description of the room
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public setGroupProfile(groupId: string, profile: any): Promise<any> {
         const path = utils.encodeUri("/groups/$groupId/profile", { $groupId: groupId });
@@ -8126,6 +8188,7 @@ export class MatrixClient extends EventEmitter {
      *     required to join.
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public setGroupJoinPolicy(groupId: string, policy: any): Promise<any> {
         const path = utils.encodeUri(
@@ -8143,6 +8206,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} groupId
      * @return {Promise} Resolves: Group users list object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroupUsers(groupId: string): Promise<any> {
         const path = utils.encodeUri("/groups/$groupId/users", { $groupId: groupId });
@@ -8153,6 +8217,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} groupId
      * @return {Promise} Resolves: Group users list object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroupInvitedUsers(groupId: string): Promise<any> {
         const path = utils.encodeUri("/groups/$groupId/invited_users", { $groupId: groupId });
@@ -8163,6 +8228,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} groupId
      * @return {Promise} Resolves: Group rooms list object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroupRooms(groupId: string): Promise<any> {
         const path = utils.encodeUri("/groups/$groupId/rooms", { $groupId: groupId });
@@ -8174,6 +8240,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} userId
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public inviteUserToGroup(groupId: string, userId: string): Promise<any> {
         const path = utils.encodeUri(
@@ -8188,6 +8255,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} userId
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public removeUserFromGroup(groupId: string, userId: string): Promise<any> {
         const path = utils.encodeUri(
@@ -8203,6 +8271,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} roleId Optional.
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public addUserToGroupSummary(groupId: string, userId: string, roleId: string): Promise<any> {
         const path = utils.encodeUri(
@@ -8219,6 +8288,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} userId
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public removeUserFromGroupSummary(groupId: string, userId: string): Promise<any> {
         const path = utils.encodeUri(
@@ -8234,6 +8304,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} categoryId Optional.
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public addRoomToGroupSummary(groupId: string, roomId: string, categoryId: string): Promise<any> {
         const path = utils.encodeUri(
@@ -8250,6 +8321,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} roomId
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public removeRoomFromGroupSummary(groupId: string, roomId: string): Promise<any> {
         const path = utils.encodeUri(
@@ -8265,6 +8337,7 @@ export class MatrixClient extends EventEmitter {
      * @param {boolean} isPublic Whether the room-group association is visible to non-members
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public addRoomToGroup(groupId: string, roomId: string, isPublic: boolean): Promise<any> {
         if (isPublic === undefined) {
@@ -8286,6 +8359,7 @@ export class MatrixClient extends EventEmitter {
      * @param {boolean} isPublic Whether the room-group association is visible to non-members
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public updateGroupRoomVisibility(groupId: string, roomId: string, isPublic: boolean): Promise<any> {
         // NB: The /config API is generic but there's not much point in exposing this yet as synapse
@@ -8306,6 +8380,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} roomId
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public removeRoomFromGroup(groupId: string, roomId: string): Promise<any> {
         const path = utils.encodeUri(
@@ -8320,6 +8395,7 @@ export class MatrixClient extends EventEmitter {
      * @param {Object} opts Additional options to send alongside the acceptance.
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public acceptGroupInvite(groupId: string, opts = null): Promise<any> {
         const path = utils.encodeUri(
@@ -8333,6 +8409,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} groupId
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public joinGroup(groupId: string): Promise<any> {
         const path = utils.encodeUri(
@@ -8346,6 +8423,7 @@ export class MatrixClient extends EventEmitter {
      * @param {string} groupId
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public leaveGroup(groupId: string): Promise<any> {
         const path = utils.encodeUri(
@@ -8358,6 +8436,7 @@ export class MatrixClient extends EventEmitter {
     /**
      * @return {Promise} Resolves: The groups to which the user is joined
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getJoinedGroups(): Promise<any> {
         const path = utils.encodeUri("/joined_groups", {});
@@ -8370,6 +8449,7 @@ export class MatrixClient extends EventEmitter {
      * @param {Object} content.profile Group profile object
      * @return {Promise} Resolves: Object with key group_id: id of the created group
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public createGroup(content: any): Promise<any> {
         const path = utils.encodeUri("/create_group", {});
@@ -8390,6 +8470,7 @@ export class MatrixClient extends EventEmitter {
      *         }
      *     }
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getPublicisedGroups(userIds: string[]): Promise<any> {
         const path = utils.encodeUri("/publicised_groups", {});
@@ -8403,6 +8484,7 @@ export class MatrixClient extends EventEmitter {
      * @param {boolean} isPublic Whether the user's membership of this group is made public
      * @return {Promise} Resolves: Empty object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public setGroupPublicity(groupId: string, isPublic: boolean): Promise<any> {
         const path = utils.encodeUri(
@@ -8567,6 +8649,7 @@ export class MatrixClient extends EventEmitter {
  * is experimental and may change.</strong>
  * @event module:client~MatrixClient#"Group"
  * @param {Group} group The newly created, fully populated group.
+ * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
  * @example
  * matrixClient.on("Group", function(group){
  *   var groupId = group.groupId;

src/crypto/EncryptionSetup.ts

@@ -59,7 +59,7 @@ export class EncryptionSetupBuilder {
      * @param {Object.<String, MatrixEvent>} accountData pre-existing account data, will only be read, not written.
      * @param {CryptoCallbacks} delegateCryptoCallbacks crypto callbacks to delegate to if the key isn't in cache yet
      */
-    constructor(accountData: Record<string, MatrixEvent>, delegateCryptoCallbacks: ICryptoCallbacks) {
+    constructor(accountData: Record<string, MatrixEvent>, delegateCryptoCallbacks?: ICryptoCallbacks) {
         this.accountDataClientAdapter = new AccountDataClientAdapter(accountData);
         this.crossSigningCallbacks = new CrossSigningCallbacks();
         this.ssssCryptoCallbacks = new SSSSCryptoCallbacks(delegateCryptoCallbacks);
@@ -351,12 +351,12 @@ class CrossSigningCallbacks implements ICryptoCallbacks, ICacheCallbacks {
 class SSSSCryptoCallbacks {
     private readonly privateKeys = new Map<string, Uint8Array>();
 
-    constructor(private readonly delegateCryptoCallbacks: ICryptoCallbacks) {}
+    constructor(private readonly delegateCryptoCallbacks?: ICryptoCallbacks) {}
 
     public async getSecretStorageKey(
         { keys }: { keys: Record<string, ISecretStorageKeyInfo> },
         name: string,
-    ): Promise<[string, Uint8Array]> {
+    ): Promise<[string, Uint8Array]|null> {
         for (const keyId of Object.keys(keys)) {
             const privateKey = this.privateKeys.get(keyId);
             if (privateKey) {
@@ -365,7 +365,7 @@ class SSSSCryptoCallbacks {
         }
         // if we don't have the key cached yet, ask
         // for it to the general crypto callbacks and cache it
-        if (this.delegateCryptoCallbacks) {
+        if (this?.delegateCryptoCallbacks?.getSecretStorageKey) {
             const result = await this.delegateCryptoCallbacks.
                 getSecretStorageKey({ keys }, name);
             if (result) {
@@ -374,6 +374,7 @@ class SSSSCryptoCallbacks {
             }
             return result;
         }
+        return null;
     }
 
     public addPrivateKey(keyId: string, keyInfo: ISecretStorageKeyInfo, privKey: Uint8Array): void {

src/crypto/algorithms/megolm.ts

@@ -101,6 +101,13 @@ interface IPayload extends Partial<IMessage> {
 }
 /* eslint-enable camelcase */
 
+interface SharedWithData {
+    // The identity key of the device we shared with
+    deviceKey: string;
+    // The message index of the ratchet we shared with that device
+    messageIndex: number;
+}
+
 /**
  * @private
  * @constructor
@@ -115,12 +122,12 @@ interface IPayload extends Partial<IMessage> {
  *
  * @property {object} sharedWithDevices
  *    devices with which we have shared the session key
- *        userId -> {deviceId -> msgindex}
+ *        userId -> {deviceId -> SharedWithData}
  */
 class OutboundSessionInfo {
     public useCount = 0;
     public creationTime: number;
-    public sharedWithDevices: Record<string, Record<string, number>> = {};
+    public sharedWithDevices: Record<string, Record<string, SharedWithData>> = {};
     public blockedDevicesNotified: Record<string, Record<string, boolean>> = {};
 
     constructor(public readonly sessionId: string, public readonly sharedHistory = false) {
@@ -150,11 +157,11 @@ class OutboundSessionInfo {
         return false;
     }
 
-    public markSharedWithDevice(userId: string, deviceId: string, chainIndex: number): void {
+    public markSharedWithDevice(userId: string, deviceId: string, deviceKey: string, chainIndex: number): void {
         if (!this.sharedWithDevices[userId]) {
             this.sharedWithDevices[userId] = {};
         }
-        this.sharedWithDevices[userId][deviceId] = chainIndex;
+        this.sharedWithDevices[userId][deviceId] = { deviceKey, messageIndex: chainIndex };
     }
 
     public markNotifiedBlockedDevice(userId: string, deviceId: string): void {
@@ -572,6 +579,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
         payload: IPayload,
     ): Promise<void> {
         const contentMap = {};
+        const deviceInfoByDeviceId = new Map<string, DeviceInfo>();
 
         const promises = [];
         for (let i = 0; i < userDeviceMap.length; i++) {
@@ -584,6 +592,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
             const userId = val.userId;
             const deviceInfo = val.deviceInfo;
             const deviceId = deviceInfo.deviceId;
+            deviceInfoByDeviceId.set(deviceId, deviceInfo);
 
             if (!contentMap[userId]) {
                 contentMap[userId] = {};
@@ -636,7 +645,10 @@ class MegolmEncryption extends EncryptionAlgorithm {
                 for (const userId of Object.keys(contentMap)) {
                     for (const deviceId of Object.keys(contentMap[userId])) {
                         session.markSharedWithDevice(
-                            userId, deviceId, chainIndex,
+                            userId,
+                            deviceId,
+                            deviceInfoByDeviceId.get(deviceId).getIdentityKey(),
+                            chainIndex,
                         );
                     }
                 }
@@ -719,8 +731,8 @@ class MegolmEncryption extends EncryptionAlgorithm {
             logger.debug(`megolm session ${sessionId} never shared with user ${userId}`);
             return;
         }
-        const sentChainIndex = obSessionInfo.sharedWithDevices[userId][device.deviceId];
-        if (sentChainIndex === undefined) {
+        const sessionSharedData = obSessionInfo.sharedWithDevices[userId][device.deviceId];
+        if (sessionSharedData === undefined) {
             logger.debug(
                 "megolm session ID " + sessionId + " never shared with device " +
                 userId + ":" + device.deviceId,
@@ -728,10 +740,18 @@ class MegolmEncryption extends EncryptionAlgorithm {
             return;
         }
 
+        if (sessionSharedData.deviceKey !== device.getIdentityKey()) {
+            logger.warn(
+                `Session has been shared with device ${device.deviceId} but with identity ` +
+                `key ${sessionSharedData.deviceKey}. Key is now ${device.getIdentityKey()}!`,
+            );
+            return;
+        }
+
         // get the key from the inbound session: the outbound one will already
         // have been ratcheted to the next chain index.
         const key = await this.olmDevice.getInboundGroupSessionKey(
-            this.roomId, senderKey, sessionId, sentChainIndex,
+            this.roomId, senderKey, sessionId, sessionSharedData.messageIndex,
         );
 
         if (!key) {
@@ -882,7 +902,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
             const deviceId = deviceInfo.deviceId;
 
             session.markSharedWithDevice(
-                userId, deviceId, key.chain_index,
+                userId, deviceId, deviceInfo.getIdentityKey(), key.chain_index,
             );
         }
 

src/crypto/index.ts

@@ -2757,12 +2757,22 @@ export class Crypto extends EventEmitter {
             delete content['m.relates_to'];
         }
 
+        // Treat element's performance metrics the same as `m.relates_to` (when present)
+        const elementPerfMetrics = content['io.element.performance_metrics'];
+        if (elementPerfMetrics) {
+            content = Object.assign({}, content);
+            delete content['io.element.performance_metrics'];
+        }
+
         const encryptedContent = await alg.encryptMessage(
             room, event.getType(), content);
 
         if (mRelatesTo) {
             encryptedContent['m.relates_to'] = mRelatesTo;
         }
+        if (elementPerfMetrics) {
+            encryptedContent['io.element.performance_metrics'] = elementPerfMetrics;
+        }
 
         event.makeEncrypted(
             "m.room.encrypted",

src/crypto/verification/request/ToDeviceChannel.js

@@ -248,7 +248,7 @@ export class ToDeviceChannel {
      */
     async sendCompleted(type, content) {
         let result;
-        if (type === REQUEST_TYPE) {
+        if (type === REQUEST_TYPE || (type === CANCEL_TYPE && !this.__deviceId)) {
             result = await this._sendToDevices(type, content, this._devices);
         } else {
             result = await this._sendToDevices(type, content, [this._deviceId]);

src/interactive-auth.ts

@@ -20,10 +20,90 @@ limitations under the License.
 
 import * as utils from "./utils";
 import { logger } from './logger';
+import { MatrixClient } from "./client";
+import { defer, IDeferred } from "./utils";
+import { MatrixError } from "./http-api";
 
 const EMAIL_STAGE_TYPE = "m.login.email.identity";
 const MSISDN_STAGE_TYPE = "m.login.msisdn";
 
+interface IFlow {
+    stages: AuthType[];
+}
+
+export interface IInputs {
+    emailAddress?: string;
+    phoneCountry?: string;
+    phoneNumber?: string;
+}
+
+export interface IStageStatus {
+    emailSid?: string;
+    errcode?: string;
+    error?: string;
+}
+
+export interface IAuthData {
+    session?: string;
+    completed?: string[];
+    flows?: IFlow[];
+    params?: Record<string, Record<string, any>>;
+    errcode?: string;
+    error?: MatrixError;
+}
+
+export enum AuthType {
+    Password = "m.login.password",
+    Recaptcha = "m.login.recaptcha",
+    Terms = "m.login.terms",
+    Email = "m.login.email.identity",
+    Msisdn = "m.login.msisdn",
+    Sso = "m.login.sso",
+    SsoUnstable = "org.matrix.login.sso",
+    Dummy = "m.login.dummy",
+}
+
+export interface IAuthDict {
+    // [key: string]: any;
+    type?: string;
+    // session?: string; // TODO
+    // TODO: Remove `user` once servers support proper UIA
+    // See https://github.com/vector-im/element-web/issues/10312
+    user?: string;
+    identifier?: any;
+    password?: string;
+    response?: string;
+    // TODO: Remove `threepid_creds` once servers support proper UIA
+    // See https://github.com/vector-im/element-web/issues/10312
+    // See https://github.com/matrix-org/matrix-doc/issues/2220
+    // eslint-disable-next-line camelcase
+    threepid_creds?: any;
+    threepidCreds?: any;
+}
+
+class NoAuthFlowFoundError extends Error {
+    public name = "NoAuthFlowFoundError";
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention, camelcase
+    constructor(m: string, public readonly required_stages: string[], public readonly flows: IFlow[]) {
+        super(m);
+    }
+}
+
+interface IOpts {
+    matrixClient: MatrixClient;
+    authData?: IAuthData;
+    inputs?: IInputs;
+    sessionId?: string;
+    clientSecret?: string;
+    emailSid?: string;
+    doRequest(auth: IAuthData, background: boolean): Promise<IAuthData>;
+    stateUpdated(nextStage: AuthType, status: IStageStatus): void;
+    requestEmailToken(email: string, secret: string, attempt: number, session: string): Promise<{ sid: string }>;
+    busyChanged?(busy: boolean): void;
+    startAuthStage?(nextStage: string): Promise<void>; // LEGACY
+}
+
 /**
  * Abstracts the logic used to drive the interactive auth process.
  *
@@ -50,12 +130,12 @@ const MSISDN_STAGE_TYPE = "m.login.msisdn";
  *     called with the new auth dict to submit the request. Also passes a
  *     second deprecated arg which is a flag set to true if this request
  *     is a background request. The busyChanged callback should be used
- *     instead of the backfround flag. Should return a promise which resolves
+ *     instead of the background flag. Should return a promise which resolves
  *     to the successful response or rejects with a MatrixError.
  *
- * @param {function(bool): Promise} opts.busyChanged
+ * @param {function(boolean): Promise} opts.busyChanged
  *     called whenever the interactive auth logic becomes busy submitting
- *     information provided by the user or finsihes. After this has been
+ *     information provided by the user or finishes. After this has been
  *     called with true the UI should indicate that a request is in progress
  *     until it is called again with false.
  *
@@ -101,33 +181,41 @@ const MSISDN_STAGE_TYPE = "m.login.msisdn";
  *     attemptAuth promise.
  *
  */
-export function InteractiveAuth(opts) {
-    this._matrixClient = opts.matrixClient;
-    this._data = opts.authData || {};
-    this._requestCallback = opts.doRequest;
-    this._busyChangedCallback = opts.busyChanged;
-    // startAuthStage included for backwards compat
-    this._stateUpdatedCallback = opts.stateUpdated || opts.startAuthStage;
-    this._resolveFunc = null;
-    this._rejectFunc = null;
-    this._inputs = opts.inputs || {};
-    this._requestEmailTokenCallback = opts.requestEmailToken;
+export class InteractiveAuth {
+    private readonly matrixClient: MatrixClient;
+    private readonly inputs: IInputs;
+    private readonly clientSecret: string;
+    private readonly requestCallback: IOpts["doRequest"];
+    private readonly busyChangedCallback?: IOpts["busyChanged"];
+    private readonly stateUpdatedCallback: IOpts["stateUpdated"];
+    private readonly requestEmailTokenCallback: IOpts["requestEmailToken"];
 
-    if (opts.sessionId) this._data.session = opts.sessionId;
-    this._clientSecret = opts.clientSecret || this._matrixClient.generateClientSecret();
-    this._emailSid = opts.emailSid;
-    if (this._emailSid === undefined) this._emailSid = null;
-    this._requestingEmailToken = false;
-
-    this._chosenFlow = null;
-    this._currentStage = null;
+    private data: IAuthData;
+    private emailSid?: string;
+    private requestingEmailToken = false;
+    private attemptAuthDeferred: IDeferred<IAuthData> = null;
+    private chosenFlow: IFlow = null;
+    private currentStage: string = null;
 
     // if we are currently trying to submit an auth dict (which includes polling)
     // the promise the will resolve/reject when it completes
-    this._submitPromise = null;
-}
+    private submitPromise: Promise<void> = null;
+
+    constructor(opts: IOpts) {
+        this.matrixClient = opts.matrixClient;
+        this.data = opts.authData || {};
+        this.requestCallback = opts.doRequest;
+        this.busyChangedCallback = opts.busyChanged;
+        // startAuthStage included for backwards compat
+        this.stateUpdatedCallback = opts.stateUpdated || opts.startAuthStage;
+        this.requestEmailTokenCallback = opts.requestEmailToken;
+        this.inputs = opts.inputs || {};
+
+        if (opts.sessionId) this.data.session = opts.sessionId;
+        this.clientSecret = opts.clientSecret || this.matrixClient.generateClientSecret();
+        this.emailSid = opts.emailSid ?? null;
+    }
 
-InteractiveAuth.prototype = {
     /**
      * begin the authentication process.
      *
@@ -135,58 +223,57 @@ InteractiveAuth.prototype = {
      * or rejects with the error on failure. Rejects with NoAuthFlowFoundError if
      *     no suitable authentication flow can be found
      */
-    attemptAuth: function() {
+    public attemptAuth(): Promise<IAuthData> {
         // This promise will be quite long-lived and will resolve when the
         // request is authenticated and completes successfully.
-        return new Promise((resolve, reject) => {
-            this._resolveFunc = resolve;
-            this._rejectFunc = reject;
+        this.attemptAuthDeferred = defer();
+        // pluck the promise out now, as doRequest may clear before we return
+        const promise = this.attemptAuthDeferred.promise;
 
-            const hasFlows = this._data && this._data.flows;
-
-            // if we have no flows, try a request to acquire the flows
-            if (!hasFlows) {
-                if (this._busyChangedCallback) this._busyChangedCallback(true);
-                // use the existing sessionid, if one is present.
-                let auth = null;
-                if (this._data.session) {
-                    auth = {
-                        session: this._data.session,
-                    };
-                }
-                this._doRequest(auth).finally(() => {
-                    if (this._busyChangedCallback) this._busyChangedCallback(false);
-                });
-            } else {
-                this._startNextAuthStage();
+        // if we have no flows, try a request to acquire the flows
+        if (!this.data?.flows) {
+            this.busyChangedCallback?.(true);
+            // use the existing sessionId, if one is present.
+            let auth = null;
+            if (this.data.session) {
+                auth = {
+                    session: this.data.session,
+                };
             }
-        });
-    },
+            this.doRequest(auth).finally(() => {
+                this.busyChangedCallback?.(false);
+            });
+        } else {
+            this.startNextAuthStage();
+        }
+
+        return promise;
+    }
 
     /**
      * Poll to check if the auth session or current stage has been
      * completed out-of-band. If so, the attemptAuth promise will
      * be resolved.
      */
-    poll: async function() {
-        if (!this._data.session) return;
+    public async poll(): Promise<void> {
+        if (!this.data.session) return;
         // likewise don't poll if there is no auth session in progress
-        if (!this._resolveFunc) return;
+        if (!this.attemptAuthDeferred) return;
         // if we currently have a request in flight, there's no point making
         // another just to check what the status is
-        if (this._submitPromise) return;
+        if (this.submitPromise) return;
 
-        let authDict = {};
-        if (this._currentStage == EMAIL_STAGE_TYPE) {
+        let authDict: IAuthDict = {};
+        if (this.currentStage == EMAIL_STAGE_TYPE) {
             // The email can be validated out-of-band, but we need to provide the
             // creds so the HS can go & check it.
-            if (this._emailSid) {
-                const creds = {
-                    sid: this._emailSid,
-                    client_secret: this._clientSecret,
+            if (this.emailSid) {
+                const creds: Record<string, string> = {
+                    sid: this.emailSid,
+                    client_secret: this.clientSecret,
                 };
-                if (await this._matrixClient.doesServerRequireIdServerParam()) {
-                    const idServerParsedUrl = new URL(this._matrixClient.getIdentityServerUrl());
+                if (await this.matrixClient.doesServerRequireIdServerParam()) {
+                    const idServerParsedUrl = new URL(this.matrixClient.getIdentityServerUrl());
                     creds.id_server = idServerParsedUrl.host;
                 }
                 authDict = {
@@ -201,16 +288,16 @@ InteractiveAuth.prototype = {
         }
 
         this.submitAuthDict(authDict, true);
-    },
+    }
 
     /**
      * get the auth session ID
      *
      * @return {string} session id
      */
-    getSessionId: function() {
-        return this._data ? this._data.session : undefined;
-    },
+    public getSessionId(): string {
+        return this.data ? this.data.session : undefined;
+    }
 
     /**
      * get the client secret used for validation sessions
@@ -218,9 +305,9 @@ InteractiveAuth.prototype = {
      *
      * @return {string} client secret
      */
-    getClientSecret: function() {
-        return this._clientSecret;
-    },
+    public getClientSecret(): string {
+        return this.clientSecret;
+    }
 
     /**
      * get the server params for a given stage
@@ -228,17 +315,13 @@ InteractiveAuth.prototype = {
      * @param {string} loginType login type for the stage
      * @return {object?} any parameters from the server for this stage
      */
-    getStageParams: function(loginType) {
-        let params = {};
-        if (this._data && this._data.params) {
-            params = this._data.params;
-        }
-        return params[loginType];
-    },
+    public getStageParams(loginType: string): Record<string, any> {
+        return this.data.params?.[loginType];
+    }
 
-    getChosenFlow() {
-        return this._chosenFlow;
-    },
+    public getChosenFlow(): IFlow {
+        return this.chosenFlow;
+    }
 
     /**
      * submit a new auth dict and fire off the request. This will either
@@ -246,38 +329,38 @@ InteractiveAuth.prototype = {
      * to be called for a new stage.
      *
      * @param {object} authData new auth dict to send to the server. Should
-     *    include a `type` propterty denoting the login type, as well as any
+     *    include a `type` property denoting the login type, as well as any
      *    other params for that stage.
-     * @param {bool} background If true, this request failing will not result
+     * @param {boolean} background If true, this request failing will not result
      *    in the attemptAuth promise being rejected. This can be set to true
      *    for requests that just poll to see if auth has been completed elsewhere.
      */
-    submitAuthDict: async function(authData, background) {
-        if (!this._resolveFunc) {
+    public async submitAuthDict(authData: IAuthDict, background = false): Promise<void> {
+        if (!this.attemptAuthDeferred) {
             throw new Error("submitAuthDict() called before attemptAuth()");
         }
 
-        if (!background && this._busyChangedCallback) {
-            this._busyChangedCallback(true);
+        if (!background) {
+            this.busyChangedCallback?.(true);
         }
 
         // if we're currently trying a request, wait for it to finish
         // as otherwise we can get multiple 200 responses which can mean
         // things like multiple logins for register requests.
-        // (but discard any expections as we only care when its done,
+        // (but discard any exceptions as we only care when its done,
         // not whether it worked or not)
-        while (this._submitPromise) {
+        while (this.submitPromise) {
             try {
-                await this._submitPromise;
+                await this.submitPromise;
             } catch (e) {
             }
         }
 
         // use the sessionid from the last request, if one is present.
         let auth;
-        if (this._data.session) {
+        if (this.data.session) {
             auth = {
-                session: this._data.session,
+                session: this.data.session,
             };
             utils.extend(auth, authData);
         } else {
@@ -287,15 +370,15 @@ InteractiveAuth.prototype = {
         try {
             // NB. the 'background' flag is deprecated by the busyChanged
             // callback and is here for backwards compat
-            this._submitPromise = this._doRequest(auth, background);
-            await this._submitPromise;
+            this.submitPromise = this.doRequest(auth, background);
+            await this.submitPromise;
         } finally {
-            this._submitPromise = null;
-            if (!background && this._busyChangedCallback) {
-                this._busyChangedCallback(false);
+            this.submitPromise = null;
+            if (!background) {
+                this.busyChangedCallback?.(false);
             }
         }
-    },
+    }
 
     /**
      * Gets the sid for the email validation session
@@ -303,9 +386,9 @@ InteractiveAuth.prototype = {
      *
      * @returns {string} The sid of the email auth session
      */
-    getEmailSid: function() {
-        return this._emailSid;
-    },
+    public getEmailSid(): string {
+        return this.emailSid;
+    }
 
     /**
      * Sets the sid for the email validation session
@@ -315,9 +398,9 @@ InteractiveAuth.prototype = {
      *
      * @param {string} sid The sid for the email validation session
      */
-    setEmailSid: function(sid) {
-        this._emailSid = sid;
-    },
+    public setEmailSid(sid: string): void {
+        this.emailSid = sid;
+    }
 
     /**
      * Fire off a request, and either resolve the promise, or call
@@ -325,33 +408,29 @@ InteractiveAuth.prototype = {
      *
      * @private
      * @param {object?} auth new auth dict, including session id
-     * @param {bool?} background If true, this request is a background poll, so it
+     * @param {boolean?} background If true, this request is a background poll, so it
      *    failing will not result in the attemptAuth promise being rejected.
      *    This can be set to true for requests that just poll to see if auth has
      *    been completed elsewhere.
      */
-    _doRequest: async function(auth, background) {
+    private async doRequest(auth: IAuthData, background = false): Promise<void> {
         try {
-            const result = await this._requestCallback(auth, background);
-            this._resolveFunc(result);
-            this._resolveFunc = null;
-            this._rejectFunc = null;
+            const result = await this.requestCallback(auth, background);
+            this.attemptAuthDeferred.resolve(result);
+            this.attemptAuthDeferred = null;
         } catch (error) {
             // sometimes UI auth errors don't come with flows
-            const errorFlows = error.data ? error.data.flows : null;
-            const haveFlows = this._data.flows || Boolean(errorFlows);
+            const errorFlows = error.data?.flows ?? null;
+            const haveFlows = this.data.flows || Boolean(errorFlows);
             if (error.httpStatus !== 401 || !error.data || !haveFlows) {
                 // doesn't look like an interactive-auth failure.
                 if (!background) {
-                    this._rejectFunc(error);
+                    this.attemptAuthDeferred?.reject(error);
                 } else {
                     // We ignore all failures here (even non-UI auth related ones)
                     // since we don't want to suddenly fail if the internet connection
                     // had a blip whilst we were polling
-                    logger.log(
-                        "Background poll request failed doing UI auth: ignoring",
-                        error,
-                    );
+                    logger.log("Background poll request failed doing UI auth: ignoring", error);
                 }
             }
             // if the error didn't come with flows, completed flows or session ID,
@@ -360,37 +439,36 @@ InteractiveAuth.prototype = {
             // has not yet been validated). This appears to be a Synapse bug, which
             // we workaround here.
             if (!error.data.flows && !error.data.completed && !error.data.session) {
-                error.data.flows = this._data.flows;
-                error.data.completed = this._data.completed;
-                error.data.session = this._data.session;
+                error.data.flows = this.data.flows;
+                error.data.completed = this.data.completed;
+                error.data.session = this.data.session;
             }
-            this._data = error.data;
+            this.data = error.data;
             try {
-                this._startNextAuthStage();
+                this.startNextAuthStage();
             } catch (e) {
-                this._rejectFunc(e);
-                this._resolveFunc = null;
-                this._rejectFunc = null;
+                this.attemptAuthDeferred.reject(e);
+                this.attemptAuthDeferred = null;
             }
 
             if (
-                !this._emailSid &&
-                !this._requestingEmailToken &&
-                this._chosenFlow.stages.includes('m.login.email.identity')
+                !this.emailSid &&
+                !this.requestingEmailToken &&
+                this.chosenFlow.stages.includes(AuthType.Email)
             ) {
                 // If we've picked a flow with email auth, we send the email
                 // now because we want the request to fail as soon as possible
                 // if the email address is not valid (ie. already taken or not
                 // registered, depending on what the operation is).
-                this._requestingEmailToken = true;
+                this.requestingEmailToken = true;
                 try {
-                    const requestTokenResult = await this._requestEmailTokenCallback(
-                        this._inputs.emailAddress,
-                        this._clientSecret,
+                    const requestTokenResult = await this.requestEmailTokenCallback(
+                        this.inputs.emailAddress,
+                        this.clientSecret,
                         1, // TODO: Multiple send attempts?
-                        this._data.session,
+                        this.data.session,
                     );
-                    this._emailSid = requestTokenResult.sid;
+                    this.emailSid = requestTokenResult.sid;
                     // NB. promise is not resolved here - at some point, doRequest
                     // will be called again and if the user has jumped through all
                     // the hoops correctly, auth will be complete and the request
@@ -404,15 +482,14 @@ InteractiveAuth.prototype = {
                     // to do) or it could be a network failure. Either way, pass
                     // the failure up as the user can't complete auth if we can't
                     // send the email, for whatever reason.
-                    this._rejectFunc(e);
-                    this._resolveFunc = null;
-                    this._rejectFunc = null;
+                    this.attemptAuthDeferred.reject(e);
+                    this.attemptAuthDeferred = null;
                 } finally {
-                    this._requestingEmailToken = false;
+                    this.requestingEmailToken = false;
                 }
             }
         }
-    },
+    }
 
     /**
      * Pick the next stage and call the callback
@@ -420,34 +497,34 @@ InteractiveAuth.prototype = {
      * @private
      * @throws {NoAuthFlowFoundError} If no suitable authentication flow can be found
      */
-    _startNextAuthStage: function() {
-        const nextStage = this._chooseStage();
+    private startNextAuthStage(): void {
+        const nextStage = this.chooseStage();
         if (!nextStage) {
             throw new Error("No incomplete flows from the server");
         }
-        this._currentStage = nextStage;
+        this.currentStage = nextStage;
 
-        if (nextStage === 'm.login.dummy') {
+        if (nextStage === AuthType.Dummy) {
             this.submitAuthDict({
                 type: 'm.login.dummy',
             });
             return;
         }
 
-        if (this._data && this._data.errcode || this._data.error) {
-            this._stateUpdatedCallback(nextStage, {
-                errcode: this._data.errcode || "",
-                error: this._data.error || "",
+        if (this.data && this.data.errcode || this.data.error) {
+            this.stateUpdatedCallback(nextStage, {
+                errcode: this.data.errcode || "",
+                error: this.data.error || "",
             });
             return;
         }
 
-        const stageStatus = {};
+        const stageStatus: IStageStatus = {};
         if (nextStage == EMAIL_STAGE_TYPE) {
-            stageStatus.emailSid = this._emailSid;
+            stageStatus.emailSid = this.emailSid;
         }
-        this._stateUpdatedCallback(nextStage, stageStatus);
-    },
+        this.stateUpdatedCallback(nextStage, stageStatus);
+    }
 
     /**
      * Pick the next auth stage
@@ -456,15 +533,15 @@ InteractiveAuth.prototype = {
      * @return {string?} login type
      * @throws {NoAuthFlowFoundError} If no suitable authentication flow can be found
      */
-    _chooseStage: function() {
-        if (this._chosenFlow === null) {
-            this._chosenFlow = this._chooseFlow();
+    private chooseStage(): AuthType {
+        if (this.chosenFlow === null) {
+            this.chosenFlow = this.chooseFlow();
         }
-        logger.log("Active flow => %s", JSON.stringify(this._chosenFlow));
-        const nextStage = this._firstUncompletedStage(this._chosenFlow);
+        logger.log("Active flow => %s", JSON.stringify(this.chosenFlow));
+        const nextStage = this.firstUncompletedStage(this.chosenFlow);
         logger.log("Next stage: %s", nextStage);
         return nextStage;
-    },
+    }
 
     /**
      * Pick one of the flows from the returned list
@@ -472,7 +549,7 @@ InteractiveAuth.prototype = {
      * be returned, otherwise, null will be returned.
      *
      * Only flows using all given inputs are chosen because it
-     * is likley to be surprising if the user provides a
+     * is likely to be surprising if the user provides a
      * credential and it is not used. For example, for registration,
      * this could result in the email not being used which would leave
      * the account with no means to reset a password.
@@ -481,14 +558,14 @@ InteractiveAuth.prototype = {
      * @return {object} flow
      * @throws {NoAuthFlowFoundError} If no suitable authentication flow can be found
      */
-    _chooseFlow: function() {
-        const flows = this._data.flows || [];
+    private chooseFlow(): IFlow {
+        const flows = this.data.flows || [];
 
         // we've been given an email or we've already done an email part
-        const haveEmail = Boolean(this._inputs.emailAddress) || Boolean(this._emailSid);
+        const haveEmail = Boolean(this.inputs.emailAddress) || Boolean(this.emailSid);
         const haveMsisdn = (
-            Boolean(this._inputs.phoneCountry) &&
-            Boolean(this._inputs.phoneNumber)
+            Boolean(this.inputs.phoneCountry) &&
+            Boolean(this.inputs.phoneNumber)
         );
 
         for (const flow of flows) {
@@ -506,16 +583,14 @@ InteractiveAuth.prototype = {
                 return flow;
             }
         }
+
+        const requiredStages: string[] = [];
+        if (haveEmail) requiredStages.push(EMAIL_STAGE_TYPE);
+        if (haveMsisdn) requiredStages.push(MSISDN_STAGE_TYPE);
         // Throw an error with a fairly generic description, but with more
         // information such that the app can give a better one if so desired.
-        const err = new Error("No appropriate authentication flow found");
-        err.name = 'NoAuthFlowFoundError';
-        err.required_stages = [];
-        if (haveEmail) err.required_stages.push(EMAIL_STAGE_TYPE);
-        if (haveMsisdn) err.required_stages.push(MSISDN_STAGE_TYPE);
-        err.available_flows = flows;
-        throw err;
-    },
+        throw new NoAuthFlowFoundError("No appropriate authentication flow found", requiredStages, flows);
+    }
 
     /**
      * Get the first uncompleted stage in the given flow
@@ -524,14 +599,13 @@ InteractiveAuth.prototype = {
      * @param {object} flow
      * @return {string} login type
      */
-    _firstUncompletedStage: function(flow) {
-        const completed = (this._data || {}).completed || [];
+    private firstUncompletedStage(flow: IFlow): AuthType {
+        const completed = this.data.completed || [];
         for (let i = 0; i < flow.stages.length; ++i) {
             const stageType = flow.stages[i];
             if (completed.indexOf(stageType) === -1) {
                 return stageType;
             }
         }
-    },
-};
-
+    }
+}

src/models/MSC3089TreeSpace.ts

@@ -18,7 +18,7 @@ import { MatrixClient } from "../client";
 import { EventType, IEncryptedFile, MsgType, UNSTABLE_MSC3089_BRANCH, UNSTABLE_MSC3089_LEAF } from "../@types/event";
 import { Room } from "./room";
 import { logger } from "../logger";
-import { MatrixEvent } from "./event";
+import { IContent, MatrixEvent } from "./event";
 import {
     averageBetweenStrings,
     DEFAULT_ALPHABET,
@@ -451,11 +451,14 @@ export class MSC3089TreeSpace {
      * @param {string} name The name of the file.
      * @param {ArrayBuffer} encryptedContents The encrypted contents.
      * @param {Partial<IEncryptedFile>} info The encrypted file information.
+     * @param {IContent} additionalContent Optional event content fields to include in the message.
      * @returns {Promise<void>} Resolves when uploaded.
      */
     public async createFile(
         name: string,
-        encryptedContents: ArrayBuffer, info: Partial<IEncryptedFile>,
+        encryptedContents: ArrayBuffer,
+        info: Partial<IEncryptedFile>,
+        additionalContent?: IContent,
     ): Promise<void> {
         const mxc = await this.client.uploadContent(new Blob([encryptedContents]), {
             includeFilename: false,
@@ -464,6 +467,7 @@ export class MSC3089TreeSpace {
         info.url = mxc;
 
         const res = await this.client.sendMessage(this.roomId, {
+            ...(additionalContent ?? {}),
             msgtype: MsgType.File,
             body: name,
             url: mxc,

src/models/event.ts

@@ -24,10 +24,18 @@ import { EventEmitter } from 'events';
 
 import { logger } from '../logger';
 import { VerificationRequest } from "../crypto/verification/request/VerificationRequest";
-import { EventType, MsgType, RelationType } from "../@types/event";
+import {
+    EventType,
+    MsgType,
+    RelationType,
+    UNSTABLE_ELEMENT_REPLY_IN_THREAD,
+} from "../@types/event";
 import { Crypto } from "../crypto";
 import { deepSortedObjectEntries } from "../utils";
 import { RoomMember } from "./room-member";
+import { Thread } from "./thread";
+import { IActionsObject } from '../pushprocessor';
+import { ReEmitter } from '../ReEmitter';
 
 /**
  * Enum for event statuses.
@@ -148,7 +156,7 @@ export interface IDecryptOptions {
 }
 
 export class MatrixEvent extends EventEmitter {
-    private pushActions: object = null;
+    private pushActions: IActionsObject = null;
     private _replacingEvent: MatrixEvent = null;
     private _localRedactionEvent: MatrixEvent = null;
     private _isCancelled = false;
@@ -190,6 +198,12 @@ export class MatrixEvent extends EventEmitter {
      */
     private txnId: string = null;
 
+    /**
+     * @experimental
+     * A reference to the thread this event belongs to
+     */
+    private thread: Thread = null;
+
     /* Set an approximate timestamp for the event relative the local clock.
      * This will inherently be approximate because it doesn't take into account
      * the time between the server putting the 'age' field on the event as it sent
@@ -211,6 +225,8 @@ export class MatrixEvent extends EventEmitter {
      */
     public verificationRequest = null;
 
+    private readonly reEmitter: ReEmitter;
+
     /**
      * Construct a Matrix Event object
      * @constructor
@@ -260,6 +276,7 @@ export class MatrixEvent extends EventEmitter {
 
         this.txnId = event.txn_id || null;
         this.localTimestamp = Date.now() - this.getAge();
+        this.reEmitter = new ReEmitter(this);
     }
 
     /**
@@ -380,6 +397,29 @@ export class MatrixEvent extends EventEmitter {
         return this.event.content || {};
     }
 
+    /**
+     * @experimental
+     * Get the event ID of the replied event
+     */
+    public get replyEventId(): string {
+        const relations = this.getWireContent()["m.relates_to"];
+        return relations?.["m.in_reply_to"]?.["event_id"];
+    }
+
+    /**
+     * @experimental
+     * Determines whether a reply should be rendered in a thread
+     * or in the main room timeline
+     */
+    public get replyInThread(): boolean {
+        const replyTo = this.getWireContent()
+            ?.["m.relates_to"]
+            ?.["m.in_reply_to"];
+        return (this.replyEventId
+            && replyTo[UNSTABLE_ELEMENT_REPLY_IN_THREAD.name])
+            || this.thread instanceof Thread;
+    }
+
     /**
      * Get the previous event content JSON. This will only return something for
      * state events which exist in the timeline.
@@ -947,7 +987,7 @@ export class MatrixEvent extends EventEmitter {
      *
      * @return {?Object} push actions
      */
-    public getPushActions(): object | null {
+    public getPushActions(): IActionsObject | null {
         return this.pushActions;
     }
 
@@ -956,7 +996,7 @@ export class MatrixEvent extends EventEmitter {
      *
      * @param {Object} pushActions push actions
      */
-    public setPushActions(pushActions: object): void {
+    public setPushActions(pushActions: IActionsObject): void {
         this.pushActions = pushActions;
     }
 
@@ -1234,10 +1274,15 @@ export class MatrixEvent extends EventEmitter {
     }
 
     /**
-     * Summarise the event as JSON for debugging. If encrypted, include both the
-     * decrypted and encrypted view of the event. This is named `toJSON` for use
-     * with `JSON.stringify` which checks objects for functions named `toJSON`
-     * and will call them to customise the output if they are defined.
+     * Summarise the event as JSON. This is currently used by React SDK's view
+     * event source feature and Seshat's event indexing, so take care when
+     * adjusting the output here.
+     *
+     * If encrypted, include both the decrypted and encrypted view of the event.
+     *
+     * This is named `toJSON` for use with `JSON.stringify` which checks objects
+     * for functions named `toJSON` and will call them to customise the output
+     * if they are defined.
      *
      * @return {Object}
      */
@@ -1265,6 +1310,21 @@ export class MatrixEvent extends EventEmitter {
     public getTxnId(): string | undefined {
         return this.txnId;
     }
+
+    /**
+     * @experimental
+     */
+    public setThread(thread: Thread): void {
+        this.thread = thread;
+        this.reEmitter.reEmit(thread, ["Thread.ready", "Thread.update"]);
+    }
+
+    /**
+     * @experimental
+     */
+    public getThread(): Thread {
+        return this.thread;
+    }
 }
 
 /* REDACT_KEEP_KEYS gives the keys we keep when an event is redacted

src/models/group.js

@@ -17,6 +17,7 @@ limitations under the License.
 
 /**
  * @module models/group
+ * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
  */
 
 import * as utils from "../utils";
@@ -34,6 +35,7 @@ import { EventEmitter } from "events";
  * @prop {Object} inviter Infomation about the user who invited the logged in user
  *       to the group, if myMembership is 'invite'.
  * @prop {string} inviter.userId The user ID of the inviter
+ * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
  */
 export function Group(groupId) {
     this.groupId = groupId;
@@ -76,6 +78,7 @@ Group.prototype.setInviter = function(inviter) {
  * This means the 'name' and 'avatarUrl' properties.
  * @event module:client~MatrixClient#"Group.profile"
  * @param {Group} group The group whose profile was updated.
+ * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
  * @example
  * matrixClient.on("Group.profile", function(group){
  *   var name = group.name;
@@ -87,6 +90,7 @@ Group.prototype.setInviter = function(inviter) {
  * the group is updated.
  * @event module:client~MatrixClient#"Group.myMembership"
  * @param {Group} group The group in which the user's membership changed
+ * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
  * @example
  * matrixClient.on("Group.myMembership", function(group){
  *   var myMembership = group.myMembership;

src/models/room-state.ts

@@ -26,6 +26,7 @@ import * as utils from "../utils";
 import { EventType } from "../@types/event";
 import { MatrixEvent } from "./event";
 import { MatrixClient } from "../client";
+import { IJoinRuleEventContent, JoinRule } from "../@types/partials";
 
 // possible statuses for out-of-band member loading
 enum OobStatus {
@@ -728,10 +729,10 @@ export class RoomState extends EventEmitter {
      * Returns the join rule based on the m.room.join_rule state event, defaulting to `invite`.
      * @returns {string} the join_rule applied to this room
      */
-    public getJoinRule(): string {
+    public getJoinRule(): JoinRule {
         const joinRuleEvent = this.getStateEvents(EventType.RoomJoinRules, "");
-        const joinRuleContent = joinRuleEvent ? joinRuleEvent.getContent() : {};
-        return joinRuleContent["join_rule"] || "invite";
+        const joinRuleContent = joinRuleEvent?.getContent<IJoinRuleEventContent>() ?? {};
+        return joinRuleContent["join_rule"] || JoinRule.Invite;
     }
 
     private updateThirdPartyTokenCache(memberEvent: MatrixEvent): void {

src/models/room.ts

@@ -32,9 +32,10 @@ import { logger } from '../logger';
 import { ReEmitter } from '../ReEmitter';
 import { EventType, RoomCreateTypeField, RoomType, UNSTABLE_ELEMENT_FUNCTIONAL_USERS } from "../@types/event";
 import { IRoomVersionsCapability, MatrixClient, PendingEventOrdering, RoomVersionStability } from "../client";
-import { ResizeMethod } from "../@types/partials";
+import { JoinRule, ResizeMethod } from "../@types/partials";
 import { Filter } from "../filter";
 import { RoomState } from "./room-state";
+import { Thread } from "./thread";
 
 // These constants are used as sane defaults when the homeserver doesn't support
 // the m.room_versions capability. In practice, KNOWN_SAFE_ROOM_VERSION should be
@@ -145,6 +146,11 @@ export class Room extends EventEmitter {
     public oldState: RoomState;
     public currentState: RoomState;
 
+    /**
+     * @experimental
+     */
+    public threads = new Set<Thread>();
+
     /**
      * Construct a new Room.
      *
@@ -857,13 +863,26 @@ export class Room extends EventEmitter {
     }
 
     /**
-     * Get an event which is stored in our unfiltered timeline set
+     * Get an event which is stored in our unfiltered timeline set or in a thread
      *
      * @param {string} eventId  event ID to look for
      * @return {?module:models/event.MatrixEvent} the given event, or undefined if unknown
      */
     public findEventById(eventId: string): MatrixEvent | undefined {
-        return this.getUnfilteredTimelineSet().findEventById(eventId);
+        let event = this.getUnfilteredTimelineSet().findEventById(eventId);
+
+        if (event) {
+            return event;
+        } else {
+            const threads = this.getThreads();
+            for (let i = 0; i < threads.length; i++) {
+                const thread = threads[i];
+                event = thread.findEventById(eventId);
+                if (event) {
+                    return event;
+                }
+            }
+        }
     }
 
     /**
@@ -1049,6 +1068,55 @@ export class Room extends EventEmitter {
         );
     }
 
+    /**
+     * @experimental
+     */
+    public addThread(thread: Thread): Set<Thread> {
+        this.threads.add(thread);
+        if (!thread.ready) {
+            thread.once("Thread.ready", this.dedupeThreads);
+            this.emit("Thread.update", thread);
+            this.reEmitter.reEmit(thread, ["Thread.update", "Thread.ready"]);
+        }
+        return this.threads;
+    }
+
+    /**
+     * @experimental
+     */
+    public getThread(eventId: string): Thread {
+        return this.getThreads().find(thread => {
+            return thread.id === eventId;
+        });
+    }
+
+    /**
+     * @experimental
+     */
+    public getThreads(): Thread[] {
+        return Array.from(this.threads.values());
+    }
+
+    /**
+     * Two threads starting from a different child event can end up
+     * with the same event root. This method ensures that the duplicates
+     * are removed
+     * @experimental
+     */
+    private dedupeThreads = (readyThread): void => {
+        const deduped = Array.from(this.threads).reduce((dedupedThreads, thread) => {
+            if (dedupedThreads.has(thread.id)) {
+                dedupedThreads.get(thread.id).merge(thread);
+            } else {
+                dedupedThreads.set(thread.id, thread);
+            }
+
+            return dedupedThreads;
+        }, new Map<string, Thread>());
+
+        this.threads = new Set<Thread>(deduped.values());
+    };
+
     /**
      * Get a member from the current room state.
      * @param {string} userId The user ID of the member.
@@ -1225,6 +1293,28 @@ export class Room extends EventEmitter {
         }
     }
 
+    /**
+     * Add an event to a thread's timeline. Will fire "Thread.update"
+     * @experimental
+     */
+    public addThreadedEvent(event: MatrixEvent): void {
+        if (event.getUnsigned().transaction_id) {
+            const existingEvent = this.txnToEvent[event.getUnsigned().transaction_id];
+            if (existingEvent) {
+                // remote echo of an event we sent earlier
+                this.handleRemoteEcho(event, existingEvent);
+            }
+        }
+
+        let thread = this.findEventById(event.replyEventId)?.getThread();
+        if (thread) {
+            thread.addEvent(event);
+        } else {
+            thread = new Thread([event], this, this.client);
+            this.addThread(thread);
+        }
+    }
+
     /**
      * Add an event to the end of this room's live timelines. Will fire
      * "Room.timeline".
@@ -1973,7 +2063,7 @@ export class Room extends EventEmitter {
      * Returns the join rule based on the m.room.join_rule state event, defaulting to `invite`.
      * @returns {string} the join_rule applied to this room
      */
-    public getJoinRule(): string {
+    public getJoinRule(): JoinRule {
         return this.currentState.getJoinRule();
     }
 

src/models/search-result.ts

@@ -31,7 +31,7 @@ export class SearchResult {
      * @return {SearchResult}
      */
 
-    static fromJson(jsonObj: ISearchResult, eventMapper: EventMapper): SearchResult {
+    public static fromJson(jsonObj: ISearchResult, eventMapper: EventMapper): SearchResult {
         const jsonContext = jsonObj.context || {} as IResultContext;
         const eventsBefore = jsonContext.events_before || [];
         const eventsAfter = jsonContext.events_after || [];
@@ -57,4 +57,3 @@ export class SearchResult {
      */
     constructor(public readonly rank: number, public readonly context: EventContext) {}
 }
-

src/models/thread.ts

@@ -0,0 +1,197 @@
+/*
+Copyright 2021 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { EventEmitter } from "events";
+import { MatrixClient } from "../matrix";
+import { MatrixEvent } from "./event";
+import { EventTimelineSet } from './event-timeline-set';
+import { Room } from './room';
+
+/**
+ * @experimental
+ */
+export class Thread extends EventEmitter {
+    /**
+     * A reference to the event ID at the top of the thread
+     */
+    private root: string;
+    /**
+     * A reference to all the events ID at the bottom of the threads
+     */
+    public readonly tail = new Set<string>();
+    private _timelineSet: EventTimelineSet;
+
+    constructor(
+        events: MatrixEvent[] = [],
+        public readonly room: Room,
+        public readonly client: MatrixClient,
+    ) {
+        super();
+        this._timelineSet = new EventTimelineSet(room, {
+            unstableClientRelationAggregation: true,
+            timelineSupport: true,
+        });
+        events.forEach(event => this.addEvent(event));
+    }
+
+    /**
+     * Add an event to the thread and updates
+     * the tail/root references if needed
+     * Will fire "Thread.update"
+     * @param event The event to add
+     */
+    public async addEvent(event: MatrixEvent): Promise<void> {
+        if (this._timelineSet.findEventById(event.getId()) || event.status !== null) {
+            return;
+        }
+
+        if (this.tail.has(event.replyEventId)) {
+            this.tail.delete(event.replyEventId);
+        }
+        this.tail.add(event.getId());
+
+        if (!event.replyEventId || !this._timelineSet.findEventById(event.replyEventId)) {
+            this.root = event.getId();
+        }
+
+        event.setThread(this);
+        this._timelineSet.addLiveEvent(event);
+
+        if (this.ready) {
+            this.client.decryptEventIfNeeded(event, {});
+            this.emit("Thread.update", this);
+        } else {
+            this.emit("Thread.update", this);
+        }
+    }
+
+    /**
+     * Completes the reply chain with all events
+     * missing from the current sync data
+     * Will fire "Thread.ready"
+     */
+    public async fetchReplyChain(): Promise<void> {
+        if (!this.ready) {
+            let mxEvent = this.room.findEventById(this.rootEvent.replyEventId);
+            if (!mxEvent) {
+                mxEvent = await this.fetchEventById(
+                    this.rootEvent.getRoomId(),
+                    this.rootEvent.replyEventId,
+                );
+            }
+
+            this.addEvent(mxEvent);
+            if (mxEvent.replyEventId) {
+                await this.fetchReplyChain();
+            } else {
+                await this.decryptEvents();
+                this.emit("Thread.ready", this);
+            }
+        }
+    }
+
+    private async decryptEvents(): Promise<void> {
+        await Promise.allSettled(
+            Array.from(this._timelineSet.getLiveTimeline().getEvents()).map(event => {
+                return this.client.decryptEventIfNeeded(event, {});
+            }),
+        );
+    }
+
+    /**
+     * Fetches an event over the network
+     */
+    private async fetchEventById(roomId: string, eventId: string): Promise<MatrixEvent> {
+        const response = await this.client.http.authedRequest(
+            undefined,
+            "GET",
+            `/rooms/${roomId}/event/${eventId}`,
+        );
+        return new MatrixEvent(response);
+    }
+
+    /**
+     * Finds an event by ID in the current thread
+     */
+    public findEventById(eventId: string) {
+        return this._timelineSet.findEventById(eventId);
+    }
+
+    /**
+     * Determines thread's ready status
+     */
+    public get ready(): boolean {
+        return this.rootEvent.replyEventId === undefined;
+    }
+
+    /**
+     * The thread ID, which is the same as the root event ID
+     */
+    public get id(): string {
+        return this.root;
+    }
+
+    /**
+     * The thread root event
+     */
+    public get rootEvent(): MatrixEvent {
+        return this.findEventById(this.root);
+    }
+
+    /**
+     * The number of messages in the thread
+     */
+    public get length(): number {
+        return this.events.length;
+    }
+
+    /**
+     * A set of mxid participating to the thread
+     */
+    public get participants(): Set<string> {
+        const participants = new Set<string>();
+        this.events.forEach(event => {
+            participants.add(event.getSender());
+        });
+        return participants;
+    }
+
+    /**
+     * A read-only getter to access the timeline set
+     */
+    public get timelineSet(): EventTimelineSet {
+        return this._timelineSet;
+    }
+
+    /**
+     * A getter for the last event added to the thread
+     */
+    public get replyToEvent(): MatrixEvent {
+        const events = this.events;
+        return events[events.length -1];
+    }
+
+    public get events(): MatrixEvent[] {
+        return this._timelineSet.getLiveTimeline().getEvents();
+    }
+
+    public merge(thread: Thread): void {
+        thread.events.forEach(event => {
+            this.addEvent(event);
+        });
+        this.events.forEach(event => event.setThread(this));
+    }
+}

src/pushprocessor.ts

@@ -1,6 +1,5 @@
 /*
-Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2017 New Vector Ltd
+Copyright 2015 - 2021 The Matrix.org Foundation C.I.C.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -17,12 +16,36 @@ limitations under the License.
 
 import { escapeRegExp, globToRegexp, isNullOrUndefined } from "./utils";
 import { logger } from './logger';
+import { MatrixClient } from "./client";
+import { MatrixEvent } from "./models/event";
+import {
+    ConditionKind,
+    IAnnotatedPushRule,
+    IContainsDisplayNameCondition,
+    IEventMatchCondition,
+    IPushRule,
+    IPushRules,
+    IRoomMemberCountCondition,
+    ISenderNotificationPermissionCondition,
+    PushRuleAction,
+    PushRuleActionName,
+    PushRuleCondition,
+    PushRuleKind,
+    PushRuleSet,
+    TweakName,
+} from "./@types/PushRules";
 
 /**
  * @module pushprocessor
  */
 
-const RULEKINDS_IN_ORDER = ['override', 'content', 'room', 'sender', 'underride'];
+const RULEKINDS_IN_ORDER = [
+    PushRuleKind.Override,
+    PushRuleKind.ContentSpecific,
+    PushRuleKind.RoomSpecific,
+    PushRuleKind.SenderSpecific,
+    PushRuleKind.Underride,
+];
 
 // The default override rules to apply to the push rules that arrive from the server.
 // We do this for two reasons:
@@ -31,7 +54,7 @@ const RULEKINDS_IN_ORDER = ['override', 'content', 'room', 'sender', 'underride'
 //      more details.
 //   2. We often want to start using push rules ahead of the server supporting them,
 //      and so we can put them here.
-const DEFAULT_OVERRIDE_RULES = [
+const DEFAULT_OVERRIDE_RULES: IPushRule[] = [
     {
         // For homeservers which don't support MSC1930 yet
         rule_id: ".m.rule.tombstone",
@@ -39,20 +62,20 @@ const DEFAULT_OVERRIDE_RULES = [
         enabled: true,
         conditions: [
             {
-                kind: "event_match",
+                kind: ConditionKind.EventMatch,
                 key: "type",
                 pattern: "m.room.tombstone",
             },
             {
-                kind: "event_match",
+                kind: ConditionKind.EventMatch,
                 key: "state_key",
                 pattern: "",
             },
         ],
         actions: [
-            "notify",
+            PushRuleActionName.Notify,
             {
-                set_tweak: "highlight",
+                set_tweak: TweakName.Highlight,
                 value: true,
             },
         ],
@@ -64,31 +87,97 @@ const DEFAULT_OVERRIDE_RULES = [
         enabled: true,
         conditions: [
             {
-                kind: "event_match",
+                kind: ConditionKind.EventMatch,
                 key: "type",
                 pattern: "m.reaction",
             },
         ],
         actions: [
-            "dont_notify",
+            PushRuleActionName.DontNotify,
         ],
     },
 ];
 
-/**
- * Construct a Push Processor.
- * @constructor
- * @param {Object} client The Matrix client object to use
- */
-export function PushProcessor(client) {
-    const cachedGlobToRegex = {
-        // $glob: RegExp,
-    };
+export interface IActionsObject {
+    notify: boolean;
+    tweaks: Partial<Record<TweakName, any>>;
+}
 
-    const matchingRuleFromKindSet = (ev, kindset) => {
-        for (let ruleKindIndex = 0;
-                ruleKindIndex < RULEKINDS_IN_ORDER.length;
-                ++ruleKindIndex) {
+export class PushProcessor {
+    /**
+     * Construct a Push Processor.
+     * @constructor
+     * @param {Object} client The Matrix client object to use
+     */
+    constructor(private readonly client: MatrixClient) {}
+
+    /**
+     * Convert a list of actions into a object with the actions as keys and their values
+     * eg. [ 'notify', { set_tweak: 'sound', value: 'default' } ]
+     *     becomes { notify: true, tweaks: { sound: 'default' } }
+     * @param {array} actionList The actions list
+     *
+     * @return {object} A object with key 'notify' (true or false) and an object of actions
+     */
+    public static actionListToActionsObject(actionList: PushRuleAction[]): IActionsObject {
+        const actionObj: IActionsObject = { notify: false, tweaks: {} };
+        for (let i = 0; i < actionList.length; ++i) {
+            const action = actionList[i];
+            if (action === PushRuleActionName.Notify) {
+                actionObj.notify = true;
+            } else if (typeof action === 'object') {
+                if (action.value === undefined) {
+                    action.value = true;
+                }
+                actionObj.tweaks[action.set_tweak] = action.value;
+            }
+        }
+        return actionObj;
+    }
+
+    /**
+     * Rewrites conditions on a client's push rules to match the defaults
+     * where applicable. Useful for upgrading push rules to more strict
+     * conditions when the server is falling behind on defaults.
+     * @param {object} incomingRules The client's existing push rules
+     * @returns {object} The rewritten rules
+     */
+    public static rewriteDefaultRules(incomingRules: IPushRules): IPushRules {
+        let newRules: IPushRules = JSON.parse(JSON.stringify(incomingRules)); // deep clone
+
+        // These lines are mostly to make the tests happy. We shouldn't run into these
+        // properties missing in practice.
+        if (!newRules) newRules = {} as IPushRules;
+        if (!newRules.global) newRules.global = {} as PushRuleSet;
+        if (!newRules.global.override) newRules.global.override = [];
+
+        // Merge the client-level defaults with the ones from the server
+        const globalOverrides = newRules.global.override;
+        for (const override of DEFAULT_OVERRIDE_RULES) {
+            const existingRule = globalOverrides
+                .find((r) => r.rule_id === override.rule_id);
+
+            if (existingRule) {
+                // Copy over the actions, default, and conditions. Don't touch the user's
+                // preference.
+                existingRule.default = override.default;
+                existingRule.conditions = override.conditions;
+                existingRule.actions = override.actions;
+            } else {
+                // Add the rule
+                const ruleId = override.rule_id;
+                logger.warn(`Adding default global override for ${ruleId}`);
+                globalOverrides.push(override);
+            }
+        }
+
+        return newRules;
+    }
+
+    private static cachedGlobToRegex: Record<string, RegExp> = {}; // $glob: RegExp
+
+    private matchingRuleFromKindSet(ev: MatrixEvent, kindset: PushRuleSet): IAnnotatedPushRule {
+        for (let ruleKindIndex = 0; ruleKindIndex < RULEKINDS_IN_ORDER.length; ++ruleKindIndex) {
             const kind = RULEKINDS_IN_ORDER[ruleKindIndex];
             const ruleset = kindset[kind];
             if (!ruleset) {
@@ -101,89 +190,96 @@ export function PushProcessor(client) {
                     continue;
                 }
 
-                const rawrule = templateRuleToRaw(kind, rule);
+                const rawrule = this.templateRuleToRaw(kind, rule);
                 if (!rawrule) {
                     continue;
                 }
 
                 if (this.ruleMatchesEvent(rawrule, ev)) {
-                    rule.kind = kind;
-                    return rule;
+                    return {
+                        ...rule,
+                        kind,
+                    };
                 }
             }
         }
         return null;
-    };
+    }
 
-    const templateRuleToRaw = function(kind, tprule) {
+    private templateRuleToRaw(kind: PushRuleKind, tprule: any): any {
         const rawrule = {
             'rule_id': tprule.rule_id,
             'actions': tprule.actions,
             'conditions': [],
         };
         switch (kind) {
-            case 'underride':
-            case 'override':
+            case PushRuleKind.Underride:
+            case PushRuleKind.Override:
                 rawrule.conditions = tprule.conditions;
                 break;
-            case 'room':
+            case PushRuleKind.RoomSpecific:
                 if (!tprule.rule_id) {
                     return null;
                 }
                 rawrule.conditions.push({
-                    'kind': 'event_match',
+                    'kind': ConditionKind.EventMatch,
                     'key': 'room_id',
                     'value': tprule.rule_id,
                 });
                 break;
-            case 'sender':
+            case PushRuleKind.SenderSpecific:
                 if (!tprule.rule_id) {
                     return null;
                 }
                 rawrule.conditions.push({
-                    'kind': 'event_match',
+                    'kind': ConditionKind.EventMatch,
                     'key': 'user_id',
                     'value': tprule.rule_id,
                 });
                 break;
-            case 'content':
+            case PushRuleKind.ContentSpecific:
                 if (!tprule.pattern) {
                     return null;
                 }
                 rawrule.conditions.push({
-                    'kind': 'event_match',
+                    'kind': ConditionKind.EventMatch,
                     'key': 'content.body',
                     'pattern': tprule.pattern,
                 });
                 break;
         }
         return rawrule;
-    };
+    }
 
-    const eventFulfillsCondition = function(cond, ev) {
-        const condition_functions = {
-            "event_match": eventFulfillsEventMatchCondition,
-            "contains_display_name": eventFulfillsDisplayNameCondition,
-            "room_member_count": eventFulfillsRoomMemberCountCondition,
-            "sender_notification_permission": eventFulfillsSenderNotifPermCondition,
-        };
-        if (condition_functions[cond.kind]) {
-            return condition_functions[cond.kind](cond, ev);
+    private eventFulfillsCondition(cond: PushRuleCondition, ev: MatrixEvent): boolean {
+        switch (cond.kind) {
+            case ConditionKind.EventMatch:
+                return this.eventFulfillsEventMatchCondition(cond, ev);
+            case ConditionKind.ContainsDisplayName:
+                return this.eventFulfillsDisplayNameCondition(cond, ev);
+            case ConditionKind.RoomMemberCount:
+                return this.eventFulfillsRoomMemberCountCondition(cond, ev);
+            case ConditionKind.SenderNotificationPermission:
+                return this.eventFulfillsSenderNotifPermCondition(cond, ev);
         }
+
         // unknown conditions: we previously matched all unknown conditions,
         // but given that rules can be added to the base rules on a server,
         // it's probably better to not match unknown conditions.
         return false;
-    };
+    }
 
-    const eventFulfillsSenderNotifPermCondition = function(cond, ev) {
+    private eventFulfillsSenderNotifPermCondition(
+        cond: ISenderNotificationPermissionCondition,
+        ev: MatrixEvent,
+    ): boolean {
         const notifLevelKey = cond['key'];
         if (!notifLevelKey) {
             return false;
         }
 
-        const room = client.getRoom(ev.getRoomId());
-        if (!room || !room.currentState) {
+        const room = this.client.getRoom(ev.getRoomId());
+        if (!room?.currentState) {
             return false;
         }
 
@@ -191,14 +287,14 @@ export function PushProcessor(client) {
         // the point the event is in the DAG. Unfortunately the js-sdk does not store
         // this.
         return room.currentState.mayTriggerNotifOfType(notifLevelKey, ev.getSender());
-    };
+    }
 
-    const eventFulfillsRoomMemberCountCondition = function(cond, ev) {
+    private eventFulfillsRoomMemberCountCondition(cond: IRoomMemberCountCondition, ev: MatrixEvent): boolean {
         if (!cond.is) {
             return false;
         }
 
-        const room = client.getRoom(ev.getRoomId());
+        const room = this.client.getRoom(ev.getRoomId());
         if (!room || !room.currentState || !room.currentState.members) {
             return false;
         }
@@ -229,9 +325,9 @@ export function PushProcessor(client) {
             default:
                 return false;
         }
-    };
+    }
 
-    const eventFulfillsDisplayNameCondition = function(cond, ev) {
+    private eventFulfillsDisplayNameCondition(cond: IContainsDisplayNameCondition, ev: MatrixEvent): boolean {
         let content = ev.getContent();
         if (ev.isEncrypted() && ev.getClearContent()) {
             content = ev.getClearContent();
@@ -240,26 +336,26 @@ export function PushProcessor(client) {
             return false;
         }
 
-        const room = client.getRoom(ev.getRoomId());
+        const room = this.client.getRoom(ev.getRoomId());
         if (!room || !room.currentState || !room.currentState.members ||
-            !room.currentState.getMember(client.credentials.userId)) {
+            !room.currentState.getMember(this.client.credentials.userId)) {
             return false;
         }
 
-        const displayName = room.currentState.getMember(client.credentials.userId).name;
+        const displayName = room.currentState.getMember(this.client.credentials.userId).name;
 
         // N.B. we can't use \b as it chokes on unicode. however \W seems to be okay
         // as shorthand for [^0-9A-Za-z_].
         const pat = new RegExp("(^|\\W)" + escapeRegExp(displayName) + "(\\W|$)", 'i');
         return content.body.search(pat) > -1;
-    };
+    }
 
-    const eventFulfillsEventMatchCondition = function(cond, ev) {
+    private eventFulfillsEventMatchCondition(cond: IEventMatchCondition, ev: MatrixEvent): boolean {
         if (!cond.key) {
             return false;
         }
 
-        const val = valueForDottedKey(cond.key, ev);
+        const val = this.valueForDottedKey(cond.key, ev);
         if (typeof val !== 'string') {
             return false;
         }
@@ -275,26 +371,26 @@ export function PushProcessor(client) {
         let regex;
 
         if (cond.key == 'content.body') {
-            regex = createCachedRegex('(^|\\W)', cond.pattern, '(\\W|$)');
+            regex = this.createCachedRegex('(^|\\W)', cond.pattern, '(\\W|$)');
         } else {
-            regex = createCachedRegex('^', cond.pattern, '$');
+            regex = this.createCachedRegex('^', cond.pattern, '$');
         }
 
         return !!val.match(regex);
-    };
+    }
 
-    const createCachedRegex = function(prefix, glob, suffix) {
-        if (cachedGlobToRegex[glob]) {
-            return cachedGlobToRegex[glob];
+    private createCachedRegex(prefix: string, glob: string, suffix: string): RegExp {
+        if (PushProcessor.cachedGlobToRegex[glob]) {
+            return PushProcessor.cachedGlobToRegex[glob];
         }
-        cachedGlobToRegex[glob] = new RegExp(
+        PushProcessor.cachedGlobToRegex[glob] = new RegExp(
             prefix + globToRegexp(glob) + suffix,
             'i', // Case insensitive
         );
-        return cachedGlobToRegex[glob];
-    };
+        return PushProcessor.cachedGlobToRegex[glob];
+    }
 
-    const valueForDottedKey = function(key, ev) {
+    private valueForDottedKey(key: string, ev: MatrixEvent): any {
         const parts = key.split('.');
         let val;
 
@@ -319,23 +415,23 @@ export function PushProcessor(client) {
             val = val[thisPart];
         }
         return val;
-    };
+    }
 
-    const matchingRuleForEventWithRulesets = function(ev, rulesets) {
+    private matchingRuleForEventWithRulesets(ev: MatrixEvent, rulesets): IAnnotatedPushRule {
         if (!rulesets) {
             return null;
         }
-        if (ev.getSender() === client.credentials.userId) {
+        if (ev.getSender() === this.client.credentials.userId) {
             return null;
         }
 
-        return matchingRuleFromKindSet(ev, rulesets.global);
-    };
+        return this.matchingRuleFromKindSet(ev, rulesets.global);
+    }
 
-    const pushActionsForEventAndRulesets = function(ev, rulesets) {
-        const rule = matchingRuleForEventWithRulesets(ev, rulesets);
+    private pushActionsForEventAndRulesets(ev: MatrixEvent, rulesets): IActionsObject {
+        const rule = this.matchingRuleForEventWithRulesets(ev, rulesets);
         if (!rule) {
-            return {};
+            return {} as IActionsObject;
         }
 
         const actionObj = PushProcessor.actionListToActionsObject(rule.actions);
@@ -344,21 +440,22 @@ export function PushProcessor(client) {
         if (actionObj.tweaks.highlight === undefined) {
             // if it isn't specified, highlight if it's a content
             // rule but otherwise not
-            actionObj.tweaks.highlight = (rule.kind == 'content');
+            actionObj.tweaks.highlight = (rule.kind == PushRuleKind.ContentSpecific);
         }
 
         return actionObj;
-    };
+    }
 
-    this.ruleMatchesEvent = function(rule, ev) {
+    public ruleMatchesEvent(rule: IPushRule, ev: MatrixEvent): boolean {
         let ret = true;
         for (let i = 0; i < rule.conditions.length; ++i) {
             const cond = rule.conditions[i];
-            ret &= eventFulfillsCondition(cond, ev);
+            // @ts-ignore
+            ret &= this.eventFulfillsCondition(cond, ev);
         }
         //console.log("Rule "+rule.rule_id+(ret ? " matches" : " doesn't match"));
         return ret;
-    };
+    }
 
     /**
      * Get the user's push actions for the given event
@@ -367,9 +464,9 @@ export function PushProcessor(client) {
      *
      * @return {PushAction}
      */
-    this.actionsForEvent = function(ev) {
-        return pushActionsForEventAndRulesets(ev, client.pushRules);
-    };
+    public actionsForEvent(ev: MatrixEvent): IActionsObject {
+        return this.pushActionsForEventAndRulesets(ev, this.client.pushRules);
+    }
 
     /**
      * Get one of the users push rules by its ID
@@ -377,85 +474,22 @@ export function PushProcessor(client) {
      * @param {string} ruleId The ID of the rule to search for
      * @return {object} The push rule, or null if no such rule was found
      */
-    this.getPushRuleById = function(ruleId) {
+    public getPushRuleById(ruleId: string): IPushRule {
         for (const scope of ['global']) {
-            if (client.pushRules[scope] === undefined) continue;
+            if (this.client.pushRules[scope] === undefined) continue;
 
             for (const kind of RULEKINDS_IN_ORDER) {
-                if (client.pushRules[scope][kind] === undefined) continue;
+                if (this.client.pushRules[scope][kind] === undefined) continue;
 
-                for (const rule of client.pushRules[scope][kind]) {
+                for (const rule of this.client.pushRules[scope][kind]) {
                     if (rule.rule_id === ruleId) return rule;
                 }
             }
         }
         return null;
-    };
+    }
 }
 
-/**
- * Convert a list of actions into a object with the actions as keys and their values
- * eg. [ 'notify', { set_tweak: 'sound', value: 'default' } ]
- *     becomes { notify: true, tweaks: { sound: 'default' } }
- * @param {array} actionlist The actions list
- *
- * @return {object} A object with key 'notify' (true or false) and an object of actions
- */
-PushProcessor.actionListToActionsObject = function(actionlist) {
-    const actionobj = { 'notify': false, 'tweaks': {} };
-    for (let i = 0; i < actionlist.length; ++i) {
-        const action = actionlist[i];
-        if (action === 'notify') {
-            actionobj.notify = true;
-        } else if (typeof action === 'object') {
-            if (action.value === undefined) {
-                action.value = true;
-            }
-            actionobj.tweaks[action.set_tweak] = action.value;
-        }
-    }
-    return actionobj;
-};
-
-/**
- * Rewrites conditions on a client's push rules to match the defaults
- * where applicable. Useful for upgrading push rules to more strict
- * conditions when the server is falling behind on defaults.
- * @param {object} incomingRules The client's existing push rules
- * @returns {object} The rewritten rules
- */
-PushProcessor.rewriteDefaultRules = function(incomingRules) {
-    let newRules = JSON.parse(JSON.stringify(incomingRules)); // deep clone
-
-    // These lines are mostly to make the tests happy. We shouldn't run into these
-    // properties missing in practice.
-    if (!newRules) newRules = {};
-    if (!newRules.global) newRules.global = {};
-    if (!newRules.global.override) newRules.global.override = [];
-
-    // Merge the client-level defaults with the ones from the server
-    const globalOverrides = newRules.global.override;
-    for (const override of DEFAULT_OVERRIDE_RULES) {
-        const existingRule = globalOverrides
-            .find((r) => r.rule_id === override.rule_id);
-
-        if (existingRule) {
-            // Copy over the actions, default, and conditions. Don't touch the user's
-            // preference.
-            existingRule.default = override.default;
-            existingRule.conditions = override.conditions;
-            existingRule.actions = override.actions;
-        } else {
-            // Add the rule
-            const ruleId = override.rule_id;
-            logger.warn(`Adding default global override for ${ruleId}`);
-            globalOverrides.push(override);
-        }
-    }
-
-    return newRules;
-};
-
 /**
  * @typedef {Object} PushAction
  * @type {Object}

src/room-hierarchy.ts

@@ -0,0 +1,149 @@
+/*
+Copyright 2021 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ * @module room-hierarchy
+ */
+
+import { Room } from "./models/room";
+import { IHierarchyRoom, IHierarchyRelation } from "./@types/spaces";
+import { MatrixClient } from "./client";
+import { EventType } from "./@types/event";
+
+export class RoomHierarchy {
+    // Map from room id to list of servers which are listed as a via somewhere in the loaded hierarchy
+    public readonly viaMap = new Map<string, Set<string>>();
+    // Map from room id to list of rooms which claim this room as their child
+    public readonly backRefs = new Map<string, string[]>();
+    // Map from room id to object
+    public readonly roomMap = new Map<string, IHierarchyRoom>();
+    private loadRequest: ReturnType<MatrixClient["getRoomHierarchy"]>;
+    private nextBatch?: string;
+    private _rooms?: IHierarchyRoom[];
+    private serverSupportError?: Error;
+
+    /**
+     * Construct a new RoomHierarchy
+     *
+     * A RoomHierarchy instance allows you to easily make use of the /hierarchy API and paginate it.
+     *
+     * @param {Room} root the root of this hierarchy
+     * @param {number} pageSize the maximum number of rooms to return per page, can be overridden per load request.
+     * @param {number} maxDepth the maximum depth to traverse the hierarchy to
+     * @param {boolean} suggestedOnly whether to only return rooms with suggested=true.
+     * @constructor
+     */
+    constructor(
+        private readonly root: Room,
+        private readonly pageSize?: number,
+        private readonly maxDepth?: number,
+        private readonly suggestedOnly = false,
+    ) {}
+
+    public get noSupport(): boolean {
+        return !!this.serverSupportError;
+    }
+
+    public get canLoadMore(): boolean {
+        return !!this.serverSupportError || !!this.nextBatch || !this._rooms;
+    }
+
+    public get rooms(): IHierarchyRoom[] {
+        return this._rooms;
+    }
+
+    public async load(pageSize = this.pageSize): Promise<IHierarchyRoom[]> {
+        if (this.loadRequest) return this.loadRequest.then(r => r.rooms);
+
+        this.loadRequest = this.root.client.getRoomHierarchy(
+            this.root.roomId,
+            pageSize,
+            this.maxDepth,
+            this.suggestedOnly,
+            this.nextBatch,
+        );
+
+        let rooms: IHierarchyRoom[];
+        try {
+            ({ rooms, next_batch: this.nextBatch } = await this.loadRequest);
+        } catch (e) {
+            if (e.errcode === "M_UNRECOGNIZED") {
+                this.serverSupportError = e;
+            } else {
+                throw e;
+            }
+
+            return [];
+        } finally {
+            this.loadRequest = null;
+        }
+
+        if (this._rooms) {
+            this._rooms = this._rooms.concat(rooms);
+        } else {
+            this._rooms = rooms;
+        }
+
+        rooms.forEach(room => {
+            this.roomMap.set(room.room_id, room);
+
+            room.children_state.forEach(ev => {
+                if (ev.type !== EventType.SpaceChild) return;
+                const childRoomId = ev.state_key;
+
+                // track backrefs for quicker hierarchy navigation
+                if (!this.backRefs.has(childRoomId)) {
+                    this.backRefs.set(childRoomId, []);
+                }
+                this.backRefs.get(childRoomId).push(ev.room_id);
+
+                // fill viaMap
+                if (Array.isArray(ev.content.via)) {
+                    if (!this.viaMap.has(childRoomId)) {
+                        this.viaMap.set(childRoomId, new Set());
+                    }
+                    const vias = this.viaMap.get(childRoomId);
+                    ev.content.via.forEach(via => vias.add(via));
+                }
+            });
+        });
+
+        return rooms;
+    }
+
+    public getRelation(parentId: string, childId: string): IHierarchyRelation {
+        return this.roomMap.get(parentId)?.children_state.find(e => e.state_key === childId);
+    }
+
+    public isSuggested(parentId: string, childId: string): boolean {
+        return this.getRelation(parentId, childId)?.content.suggested;
+    }
+
+    // locally remove a relation as a form of local echo
+    public removeRelation(parentId: string, childId: string): void {
+        const backRefs = this.backRefs.get(childId);
+        if (backRefs?.length === 1) {
+            this.backRefs.delete(childId);
+        } else if (backRefs?.length) {
+            this.backRefs.set(childId, backRefs.filter(ref => ref !== parentId));
+        }
+
+        const room = this.roomMap.get(parentId);
+        if (room) {
+            room.children_state = room.children_state.filter(ev => ev.state_key !== childId);
+        }
+    }
+}

src/scheduler.js

@@ -1,327 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/**
- * This is an internal module which manages queuing, scheduling and retrying
- * of requests.
- * @module scheduler
- */
-import * as utils from "./utils";
-import { logger } from './logger';
-
-const DEBUG = false;  // set true to enable console logging.
-
-/**
- * Construct a scheduler for Matrix. Requires
- * {@link module:scheduler~MatrixScheduler#setProcessFunction} to be provided
- * with a way of processing events.
- * @constructor
- * @param {module:scheduler~retryAlgorithm} retryAlgorithm Optional. The retry
- * algorithm to apply when determining when to try to send an event again.
- * Defaults to {@link module:scheduler~MatrixScheduler.RETRY_BACKOFF_RATELIMIT}.
- * @param {module:scheduler~queueAlgorithm} queueAlgorithm Optional. The queuing
- * algorithm to apply when determining which events should be sent before the
- * given event. Defaults to {@link module:scheduler~MatrixScheduler.QUEUE_MESSAGES}.
- */
-export function MatrixScheduler(retryAlgorithm, queueAlgorithm) {
-    this.retryAlgorithm = retryAlgorithm || MatrixScheduler.RETRY_BACKOFF_RATELIMIT;
-    this.queueAlgorithm = queueAlgorithm || MatrixScheduler.QUEUE_MESSAGES;
-    this._queues = {
-        // queueName: [{
-        //  event: MatrixEvent,  // event to send
-        //  defer: Deferred,  // defer to resolve/reject at the END of the retries
-        //  attempts: Number  // number of times we've called processFn
-        // }, ...]
-    };
-    this._activeQueues = [];
-    this._procFn = null;
-}
-
-/**
- * Retrieve a queue based on an event. The event provided does not need to be in
- * the queue.
- * @param {MatrixEvent} event An event to get the queue for.
- * @return {?Array<MatrixEvent>} A shallow copy of events in the queue or null.
- * Modifying this array will not modify the list itself. Modifying events in
- * this array <i>will</i> modify the underlying event in the queue.
- * @see MatrixScheduler.removeEventFromQueue To remove an event from the queue.
- */
-MatrixScheduler.prototype.getQueueForEvent = function(event) {
-    const name = this.queueAlgorithm(event);
-    if (!name || !this._queues[name]) {
-        return null;
-    }
-    return this._queues[name].map(function(obj) {
-        return obj.event;
-    });
-};
-
-/**
- * Remove this event from the queue. The event is equal to another event if they
- * have the same ID returned from event.getId().
- * @param {MatrixEvent} event The event to remove.
- * @return {boolean} True if this event was removed.
- */
-MatrixScheduler.prototype.removeEventFromQueue = function(event) {
-    const name = this.queueAlgorithm(event);
-    if (!name || !this._queues[name]) {
-        return false;
-    }
-    let removed = false;
-    utils.removeElement(this._queues[name], function(element) {
-        if (element.event.getId() === event.getId()) {
-            // XXX we should probably reject the promise?
-            // https://github.com/matrix-org/matrix-js-sdk/issues/496
-            removed = true;
-            return true;
-        }
-    });
-    return removed;
-};
-
-/**
- * Set the process function. Required for events in the queue to be processed.
- * If set after events have been added to the queue, this will immediately start
- * processing them.
- * @param {module:scheduler~processFn} fn The function that can process events
- * in the queue.
- */
-MatrixScheduler.prototype.setProcessFunction = function(fn) {
-    this._procFn = fn;
-    _startProcessingQueues(this);
-};
-
-/**
- * Queue an event if it is required and start processing queues.
- * @param {MatrixEvent} event The event that may be queued.
- * @return {?Promise} A promise if the event was queued, which will be
- * resolved or rejected in due time, else null.
- */
-MatrixScheduler.prototype.queueEvent = function(event) {
-    const queueName = this.queueAlgorithm(event);
-    if (!queueName) {
-        return null;
-    }
-    // add the event to the queue and make a deferred for it.
-    if (!this._queues[queueName]) {
-        this._queues[queueName] = [];
-    }
-    const defer = utils.defer();
-    this._queues[queueName].push({
-        event: event,
-        defer: defer,
-        attempts: 0,
-    });
-    debuglog(
-        "Queue algorithm dumped event %s into queue '%s'",
-        event.getId(), queueName,
-    );
-    _startProcessingQueues(this);
-    return defer.promise;
-};
-
-/**
- * Retries events up to 4 times using exponential backoff. This produces wait
- * times of 2, 4, 8, and 16 seconds (30s total) after which we give up. If the
- * failure was due to a rate limited request, the time specified in the error is
- * waited before being retried.
- * @param {MatrixEvent} event
- * @param {Number} attempts
- * @param {MatrixError} err
- * @return {Number}
- * @see module:scheduler~retryAlgorithm
- */
-MatrixScheduler.RETRY_BACKOFF_RATELIMIT = function(event, attempts, err) {
-    if (err.httpStatus === 400 || err.httpStatus === 403 || err.httpStatus === 401) {
-        // client error; no amount of retrying with save you now.
-        return -1;
-    }
-    // we ship with browser-request which returns { cors: rejected } when trying
-    // with no connection, so if we match that, give up since they have no conn.
-    if (err.cors === "rejected") {
-        return -1;
-    }
-
-    // if event that we are trying to send is too large in any way then retrying won't help
-    if (err.name === "M_TOO_LARGE") {
-        return -1;
-    }
-
-    if (err.name === "M_LIMIT_EXCEEDED") {
-        const waitTime = err.data.retry_after_ms;
-        if (waitTime > 0) {
-            return waitTime;
-        }
-    }
-    if (attempts > 4) {
-        return -1; // give up
-    }
-    return (1000 * Math.pow(2, attempts));
-};
-
-/**
- * Queues <code>m.room.message</code> events and lets other events continue
- * concurrently.
- * @param {MatrixEvent} event
- * @return {string}
- * @see module:scheduler~queueAlgorithm
- */
-MatrixScheduler.QUEUE_MESSAGES = function(event) {
-    // enqueue messages or events that associate with another event (redactions and relations)
-    if (event.getType() === "m.room.message" || event.hasAssocation()) {
-        // put these events in the 'message' queue.
-        return "message";
-    }
-    // allow all other events continue concurrently.
-    return null;
-};
-
-function _startProcessingQueues(scheduler) {
-    if (!scheduler._procFn) {
-        return;
-    }
-    // for each inactive queue with events in them
-    Object.keys(scheduler._queues)
-        .filter(function(queueName) {
-            return scheduler._activeQueues.indexOf(queueName) === -1 &&
-                    scheduler._queues[queueName].length > 0;
-        })
-        .forEach(function(queueName) {
-            // mark the queue as active
-            scheduler._activeQueues.push(queueName);
-            // begin processing the head of the queue
-            debuglog("Spinning up queue: '%s'", queueName);
-            _processQueue(scheduler, queueName);
-        });
-}
-
-function _processQueue(scheduler, queueName) {
-    // get head of queue
-    const obj = _peekNextEvent(scheduler, queueName);
-    if (!obj) {
-        // queue is empty. Mark as inactive and stop recursing.
-        const index = scheduler._activeQueues.indexOf(queueName);
-        if (index >= 0) {
-            scheduler._activeQueues.splice(index, 1);
-        }
-        debuglog("Stopping queue '%s' as it is now empty", queueName);
-        return;
-    }
-    debuglog(
-        "Queue '%s' has %s pending events",
-        queueName, scheduler._queues[queueName].length,
-    );
-    // fire the process function and if it resolves, resolve the deferred. Else
-    // invoke the retry algorithm.
-
-    // First wait for a resolved promise, so the resolve handlers for
-    // the deferred of the previously sent event can run.
-    // This way enqueued relations/redactions to enqueued events can receive
-    // the remove id of their target before being sent.
-    Promise.resolve().then(() => {
-        return scheduler._procFn(obj.event);
-    }).then(function(res) {
-        // remove this from the queue
-        _removeNextEvent(scheduler, queueName);
-        debuglog("Queue '%s' sent event %s", queueName, obj.event.getId());
-        obj.defer.resolve(res);
-        // keep processing
-        _processQueue(scheduler, queueName);
-    }, function(err) {
-        obj.attempts += 1;
-        // ask the retry algorithm when/if we should try again
-        const waitTimeMs = scheduler.retryAlgorithm(obj.event, obj.attempts, err);
-        debuglog(
-            "retry(%s) err=%s event_id=%s waitTime=%s",
-            obj.attempts, err, obj.event.getId(), waitTimeMs,
-        );
-        if (waitTimeMs === -1) {  // give up (you quitter!)
-            debuglog(
-                "Queue '%s' giving up on event %s", queueName, obj.event.getId(),
-            );
-            // remove this from the queue
-            _removeNextEvent(scheduler, queueName);
-            obj.defer.reject(err);
-            // process next event
-            _processQueue(scheduler, queueName);
-        } else {
-            setTimeout(function() {
-                _processQueue(scheduler, queueName);
-            }, waitTimeMs);
-        }
-    });
-}
-
-function _peekNextEvent(scheduler, queueName) {
-    const queue = scheduler._queues[queueName];
-    if (!Array.isArray(queue)) {
-        return null;
-    }
-    return queue[0];
-}
-
-function _removeNextEvent(scheduler, queueName) {
-    const queue = scheduler._queues[queueName];
-    if (!Array.isArray(queue)) {
-        return null;
-    }
-    return queue.shift();
-}
-
-function debuglog() {
-    if (DEBUG) {
-        logger.log(...arguments);
-    }
-}
-
-/**
- * The retry algorithm to apply when retrying events. To stop retrying, return
- * <code>-1</code>. If this event was part of a queue, it will be removed from
- * the queue.
- * @callback retryAlgorithm
- * @param {MatrixEvent} event The event being retried.
- * @param {Number} attempts The number of failed attempts. This will always be
- * >= 1.
- * @param {MatrixError} err The most recent error message received when trying
- * to send this event.
- * @return {Number} The number of milliseconds to wait before trying again. If
- * this is 0, the request will be immediately retried. If this is
- * <code>-1</code>, the event will be marked as
- * {@link module:models/event.EventStatus.NOT_SENT} and will not be retried.
- */
-
-/**
- * The queuing algorithm to apply to events. This function must be idempotent as
- * it may be called multiple times with the same event. All queues created are
- * serviced in a FIFO manner. To send the event ASAP, return <code>null</code>
- * which will not put this event in a queue. Events that fail to send that form
- * part of a queue will be removed from the queue and the next event in the
- * queue will be sent.
- * @callback queueAlgorithm
- * @param {MatrixEvent} event The event to be sent.
- * @return {string} The name of the queue to put the event into. If a queue with
- * this name does not exist, it will be created. If this is <code>null</code>,
- * the event is not put into a queue and will be sent concurrently.
- */
-
- /**
- * The function to invoke to process (send) events in the queue.
- * @callback processFn
- * @param {MatrixEvent} event The event to send.
- * @return {Promise} Resolved/rejected depending on the outcome of the request.
- */
-

src/scheduler.ts

@@ -0,0 +1,329 @@
+/*
+Copyright 2015 - 2021 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ * This is an internal module which manages queuing, scheduling and retrying
+ * of requests.
+ * @module scheduler
+ */
+import * as utils from "./utils";
+import { logger } from './logger';
+import { MatrixEvent } from "./models/event";
+import { EventType } from "./@types/event";
+import { IDeferred } from "./utils";
+import { MatrixError } from "./http-api";
+import { ISendEventResponse } from "./@types/requests";
+
+const DEBUG = false;  // set true to enable console logging.
+
+interface IQueueEntry<T> {
+    event: MatrixEvent;
+    defer: IDeferred<T>;
+    attempts: number;
+}
+
+type ProcessFunction<T> = (event: MatrixEvent) => Promise<T>;
+
+/**
+ * Construct a scheduler for Matrix. Requires
+ * {@link module:scheduler~MatrixScheduler#setProcessFunction} to be provided
+ * with a way of processing events.
+ * @constructor
+ * @param {module:scheduler~retryAlgorithm} retryAlgorithm Optional. The retry
+ * algorithm to apply when determining when to try to send an event again.
+ * Defaults to {@link module:scheduler~MatrixScheduler.RETRY_BACKOFF_RATELIMIT}.
+ * @param {module:scheduler~queueAlgorithm} queueAlgorithm Optional. The queuing
+ * algorithm to apply when determining which events should be sent before the
+ * given event. Defaults to {@link module:scheduler~MatrixScheduler.QUEUE_MESSAGES}.
+ */
+// eslint-disable-next-line camelcase
+export class MatrixScheduler<T = ISendEventResponse> {
+    /**
+     * Retries events up to 4 times using exponential backoff. This produces wait
+     * times of 2, 4, 8, and 16 seconds (30s total) after which we give up. If the
+     * failure was due to a rate limited request, the time specified in the error is
+     * waited before being retried.
+     * @param {MatrixEvent} event
+     * @param {Number} attempts
+     * @param {MatrixError} err
+     * @return {Number}
+     * @see module:scheduler~retryAlgorithm
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public static RETRY_BACKOFF_RATELIMIT(event: MatrixEvent, attempts: number, err: MatrixError): number {
+        if (err.httpStatus === 400 || err.httpStatus === 403 || err.httpStatus === 401) {
+            // client error; no amount of retrying with save you now.
+            return -1;
+        }
+        // we ship with browser-request which returns { cors: rejected } when trying
+        // with no connection, so if we match that, give up since they have no conn.
+        if (err.cors === "rejected") {
+            return -1;
+        }
+
+        // if event that we are trying to send is too large in any way then retrying won't help
+        if (err.name === "M_TOO_LARGE") {
+            return -1;
+        }
+
+        if (err.name === "M_LIMIT_EXCEEDED") {
+            const waitTime = err.data.retry_after_ms;
+            if (waitTime > 0) {
+                return waitTime;
+            }
+        }
+        if (attempts > 4) {
+            return -1; // give up
+        }
+        return (1000 * Math.pow(2, attempts));
+    }
+
+    /**
+     * Queues <code>m.room.message</code> events and lets other events continue
+     * concurrently.
+     * @param {MatrixEvent} event
+     * @return {string}
+     * @see module:scheduler~queueAlgorithm
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public static QUEUE_MESSAGES(event: MatrixEvent) {
+        // enqueue messages or events that associate with another event (redactions and relations)
+        if (event.getType() === EventType.RoomMessage || event.hasAssocation()) {
+            // put these events in the 'message' queue.
+            return "message";
+        }
+        // allow all other events continue concurrently.
+        return null;
+    }
+
+    // queueName: [{
+    //  event: MatrixEvent,  // event to send
+    //  defer: Deferred,  // defer to resolve/reject at the END of the retries
+    //  attempts: Number  // number of times we've called processFn
+    // }, ...]
+    private readonly queues: Record<string, IQueueEntry<T>[]> = {};
+    private activeQueues: string[] = [];
+    private procFn: ProcessFunction<T> = null;
+
+    constructor(
+        public readonly retryAlgorithm = MatrixScheduler.RETRY_BACKOFF_RATELIMIT,
+        public readonly queueAlgorithm = MatrixScheduler.QUEUE_MESSAGES,
+    ) {}
+
+    /**
+     * Retrieve a queue based on an event. The event provided does not need to be in
+     * the queue.
+     * @param {MatrixEvent} event An event to get the queue for.
+     * @return {?Array<MatrixEvent>} A shallow copy of events in the queue or null.
+     * Modifying this array will not modify the list itself. Modifying events in
+     * this array <i>will</i> modify the underlying event in the queue.
+     * @see MatrixScheduler.removeEventFromQueue To remove an event from the queue.
+     */
+    public getQueueForEvent(event: MatrixEvent): MatrixEvent[] {
+        const name = this.queueAlgorithm(event);
+        if (!name || !this.queues[name]) {
+            return null;
+        }
+        return this.queues[name].map(function(obj) {
+            return obj.event;
+        });
+    }
+
+    /**
+     * Remove this event from the queue. The event is equal to another event if they
+     * have the same ID returned from event.getId().
+     * @param {MatrixEvent} event The event to remove.
+     * @return {boolean} True if this event was removed.
+     */
+    public removeEventFromQueue(event: MatrixEvent): boolean {
+        const name = this.queueAlgorithm(event);
+        if (!name || !this.queues[name]) {
+            return false;
+        }
+        let removed = false;
+        utils.removeElement(this.queues[name], (element) => {
+            if (element.event.getId() === event.getId()) {
+                // XXX we should probably reject the promise?
+                // https://github.com/matrix-org/matrix-js-sdk/issues/496
+                removed = true;
+                return true;
+            }
+        });
+        return removed;
+    }
+
+    /**
+     * Set the process function. Required for events in the queue to be processed.
+     * If set after events have been added to the queue, this will immediately start
+     * processing them.
+     * @param {module:scheduler~processFn} fn The function that can process events
+     * in the queue.
+     */
+    public setProcessFunction(fn: ProcessFunction<T>): void {
+        this.procFn = fn;
+        this.startProcessingQueues();
+    }
+
+    /**
+     * Queue an event if it is required and start processing queues.
+     * @param {MatrixEvent} event The event that may be queued.
+     * @return {?Promise} A promise if the event was queued, which will be
+     * resolved or rejected in due time, else null.
+     */
+    public queueEvent(event: MatrixEvent): Promise<T> | null {
+        const queueName = this.queueAlgorithm(event);
+        if (!queueName) {
+            return null;
+        }
+        // add the event to the queue and make a deferred for it.
+        if (!this.queues[queueName]) {
+            this.queues[queueName] = [];
+        }
+        const defer = utils.defer<T>();
+        this.queues[queueName].push({
+            event: event,
+            defer: defer,
+            attempts: 0,
+        });
+        debuglog("Queue algorithm dumped event %s into queue '%s'", event.getId(), queueName);
+        this.startProcessingQueues();
+        return defer.promise;
+    }
+
+    private startProcessingQueues(): void {
+        if (!this.procFn) return;
+        // for each inactive queue with events in them
+        Object.keys(this.queues)
+            .filter((queueName) => {
+                return this.activeQueues.indexOf(queueName) === -1 &&
+                    this.queues[queueName].length > 0;
+            })
+            .forEach((queueName) => {
+                // mark the queue as active
+                this.activeQueues.push(queueName);
+                // begin processing the head of the queue
+                debuglog("Spinning up queue: '%s'", queueName);
+                this.processQueue(queueName);
+            });
+    }
+
+    private processQueue = (queueName: string): void => {
+        // get head of queue
+        const obj = this.peekNextEvent(queueName);
+        if (!obj) {
+            // queue is empty. Mark as inactive and stop recursing.
+            const index = this.activeQueues.indexOf(queueName);
+            if (index >= 0) {
+                this.activeQueues.splice(index, 1);
+            }
+            debuglog("Stopping queue '%s' as it is now empty", queueName);
+            return;
+        }
+        debuglog("Queue '%s' has %s pending events", queueName, this.queues[queueName].length);
+        // fire the process function and if it resolves, resolve the deferred. Else
+        // invoke the retry algorithm.
+
+        // First wait for a resolved promise, so the resolve handlers for
+        // the deferred of the previously sent event can run.
+        // This way enqueued relations/redactions to enqueued events can receive
+        // the remove id of their target before being sent.
+        Promise.resolve().then(() => {
+            return this.procFn(obj.event);
+        }).then((res) => {
+            // remove this from the queue
+            this.removeNextEvent(queueName);
+            debuglog("Queue '%s' sent event %s", queueName, obj.event.getId());
+            obj.defer.resolve(res);
+            // keep processing
+            this.processQueue(queueName);
+        }, (err) => {
+            obj.attempts += 1;
+            // ask the retry algorithm when/if we should try again
+            const waitTimeMs = this.retryAlgorithm(obj.event, obj.attempts, err);
+            debuglog("retry(%s) err=%s event_id=%s waitTime=%s", obj.attempts, err, obj.event.getId(), waitTimeMs);
+            if (waitTimeMs === -1) {  // give up (you quitter!)
+                debuglog("Queue '%s' giving up on event %s", queueName, obj.event.getId());
+                // remove this from the queue
+                this.removeNextEvent(queueName);
+                obj.defer.reject(err);
+                // process next event
+                this.processQueue(queueName);
+            } else {
+                setTimeout(this.processQueue, waitTimeMs, queueName);
+            }
+        });
+    };
+
+    private peekNextEvent(queueName: string): IQueueEntry<T> {
+        const queue = this.queues[queueName];
+        if (!Array.isArray(queue)) {
+            return null;
+        }
+        return queue[0];
+    }
+
+    private removeNextEvent(queueName: string): IQueueEntry<T> {
+        const queue = this.queues[queueName];
+        if (!Array.isArray(queue)) {
+            return null;
+        }
+        return queue.shift();
+    }
+}
+
+function debuglog(...args) {
+    if (DEBUG) {
+        logger.log(...args);
+    }
+}
+
+/**
+ * The retry algorithm to apply when retrying events. To stop retrying, return
+ * <code>-1</code>. If this event was part of a queue, it will be removed from
+ * the queue.
+ * @callback retryAlgorithm
+ * @param {MatrixEvent} event The event being retried.
+ * @param {Number} attempts The number of failed attempts. This will always be
+ * >= 1.
+ * @param {MatrixError} err The most recent error message received when trying
+ * to send this event.
+ * @return {Number} The number of milliseconds to wait before trying again. If
+ * this is 0, the request will be immediately retried. If this is
+ * <code>-1</code>, the event will be marked as
+ * {@link module:models/event.EventStatus.NOT_SENT} and will not be retried.
+ */
+
+/**
+ * The queuing algorithm to apply to events. This function must be idempotent as
+ * it may be called multiple times with the same event. All queues created are
+ * serviced in a FIFO manner. To send the event ASAP, return <code>null</code>
+ * which will not put this event in a queue. Events that fail to send that form
+ * part of a queue will be removed from the queue and the next event in the
+ * queue will be sent.
+ * @callback queueAlgorithm
+ * @param {MatrixEvent} event The event to be sent.
+ * @return {string} The name of the queue to put the event into. If a queue with
+ * this name does not exist, it will be created. If this is <code>null</code>,
+ * the event is not put into a queue and will be sent concurrently.
+ */
+
+/**
+ * The function to invoke to process (send) events in the queue.
+ * @callback processFn
+ * @param {MatrixEvent} event The event to send.
+ * @return {Promise} Resolved/rejected depending on the outcome of the request.
+ */
+

src/store/index.ts

@@ -56,6 +56,7 @@ export interface IStore {
     /**
      * No-op.
      * @param {Group} group
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     storeGroup(group: Group);
 
@@ -63,12 +64,14 @@ export interface IStore {
      * No-op.
      * @param {string} groupId
      * @return {null}
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     getGroup(groupId: string): Group | null;
 
     /**
      * No-op.
      * @return {Array} An empty array.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     getGroups(): Group[];
 

src/store/memory.ts

@@ -93,6 +93,7 @@ export class MemoryStore implements IStore {
     /**
      * Store the given room.
      * @param {Group} group The group to be stored
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public storeGroup(group: Group) {
         this.groups[group.groupId] = group;
@@ -102,6 +103,7 @@ export class MemoryStore implements IStore {
      * Retrieve a group by its group ID.
      * @param {string} groupId The group ID.
      * @return {Group} The group or null.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroup(groupId: string): Group | null {
         return this.groups[groupId] || null;
@@ -110,6 +112,7 @@ export class MemoryStore implements IStore {
     /**
      * Retrieve all known groups.
      * @return {Group[]} A list of groups, which may be empty.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroups(): Group[] {
         return Object.values(this.groups);

src/store/stub.ts

@@ -61,6 +61,7 @@ export class StubStore implements IStore {
     /**
      * No-op.
      * @param {Group} group
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public storeGroup(group: Group) {}
 
@@ -68,6 +69,7 @@ export class StubStore implements IStore {
      * No-op.
      * @param {string} groupId
      * @return {null}
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroup(groupId: string): Group | null {
         return null;
@@ -76,6 +78,7 @@ export class StubStore implements IStore {
     /**
      * No-op.
      * @return {Array} An empty array.
+     * @deprecated groups/communities never made it to the spec and support for them is being discontinued.
      */
     public getGroups(): Group[] {
         return [];

src/sync.ts

@@ -52,6 +52,8 @@ import {
 import { MatrixEvent } from "./models/event";
 import { MatrixError } from "./http-api";
 import { ISavedSync } from "./store";
+import { EventType } from "./@types/event";
+import { IPushRules } from "./@types/PushRules";
 
 const DEBUG = true;
 
@@ -146,6 +148,7 @@ export class SyncApi {
         this.opts.resolveInvitesToProfiles = this.opts.resolveInvitesToProfiles || false;
         this.opts.pollTimeout = this.opts.pollTimeout || (30 * 1000);
         this.opts.pendingEventOrdering = this.opts.pendingEventOrdering || PendingEventOrdering.Chronological;
+        this.opts.experimentalThreadSupport = this.opts.experimentalThreadSupport === true;
 
         if (!opts.canResetEntireTimeline) {
             opts.canResetEntireTimeline = (roomId: string) => {
@@ -281,8 +284,9 @@ export class SyncApi {
                     return;
                 }
                 leaveObj.timeline = leaveObj.timeline || {};
-                const timelineEvents =
-                    this.mapSyncEventsFormat(leaveObj.timeline, room);
+                const events = this.mapSyncEventsFormat(leaveObj.timeline, room);
+                const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(events);
+
                 const stateEvents = this.mapSyncEventsFormat(leaveObj.state, room);
 
                 // set the back-pagination token. Do this *before* adding any
@@ -291,17 +295,39 @@ export class SyncApi {
                     EventTimeline.BACKWARDS);
 
                 this.processRoomEvents(room, stateEvents, timelineEvents);
+                this.processThreadEvents(room, threadedEvents);
 
                 room.recalculate();
                 client.store.storeRoom(room);
                 client.emit("Room", room);
 
-                this.processEventsForNotifs(room, timelineEvents);
+                this.processEventsForNotifs(room, events);
             });
             return rooms;
         });
     }
 
+    /**
+     * Split events between the ones that will end up in the main
+     * room timeline versus the one that need to be processed in a thread
+     * @experimental
+     */
+    public partitionThreadedEvents(events: MatrixEvent[]): [MatrixEvent[], MatrixEvent[]] {
+        if (this.opts.experimentalThreadSupport) {
+            return events.reduce((memo, event: MatrixEvent) => {
+                memo[event.replyInThread ? 1 : 0].push(event);
+                return memo;
+            }, [[], []]);
+        } else {
+            // When `experimentalThreadSupport` is disabled
+            // treat all events as timelineEvents
+            return [
+                events,
+                [],
+            ];
+        }
+    }
+
     /**
      * Peek into a room. This will result in the room in question being synced so it
      * is accessible via getRooms(). Live updates for the room will be provided.
@@ -1065,8 +1091,8 @@ export class SyncApi {
                     // honour push rules that were previously cached. Base rules
                     // will be updated when we receive push rules via getPushRules
                     // (see sync) before syncing over the network.
-                    if (accountDataEvent.getType() === 'm.push_rules') {
-                        const rules = accountDataEvent.getContent();
+                    if (accountDataEvent.getType() === EventType.PushRules) {
+                        const rules = accountDataEvent.getContent<IPushRules>();
                         client.pushRules = PushProcessor.rewriteDefaultRules(rules);
                     }
                     const prevEvent = prevEventsMap[accountDataEvent.getId()];
@@ -1191,7 +1217,7 @@ export class SyncApi {
             // this helps large account to speed up faster
             // room::decryptCriticalEvent is in charge of decrypting all the events
             // required for a client to function properly
-            const timelineEvents = this.mapSyncEventsFormat(joinObj.timeline, room, false);
+            const events = this.mapSyncEventsFormat(joinObj.timeline, room, false);
             const ephemeralEvents = this.mapSyncEventsFormat(joinObj.ephemeral);
             const accountDataEvents = this.mapSyncEventsFormat(joinObj.account_data);
 
@@ -1238,8 +1264,8 @@ export class SyncApi {
                 // which we'll try to paginate but not get any new events (which
                 // will stop us linking the empty timeline into the chain).
                 //
-                for (let i = timelineEvents.length - 1; i >= 0; i--) {
-                    const eventId = timelineEvents[i].getId();
+                for (let i = events.length - 1; i >= 0; i--) {
+                    const eventId = events[i].getId();
                     if (room.getTimelineForEvent(eventId)) {
                         debuglog("Already have event " + eventId + " in limited " +
                             "sync - not resetting");
@@ -1248,7 +1274,7 @@ export class SyncApi {
                         // we might still be missing some of the events before i;
                         // we don't want to be adding them to the end of the
                         // timeline because that would put them out of order.
-                        timelineEvents.splice(0, i);
+                        events.splice(0, i);
 
                         // XXX: there's a problem here if the skipped part of the
                         // timeline modifies the state set in stateEvents, because
@@ -1278,7 +1304,10 @@ export class SyncApi {
                 }
             }
 
+            const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(events);
+
             this.processRoomEvents(room, stateEvents, timelineEvents, syncEventData.fromCache);
+            this.processThreadEvents(room, threadedEvents);
 
             // set summary after processing events,
             // because it will trigger a name calculation
@@ -1299,7 +1328,7 @@ export class SyncApi {
                 client.emit("Room", room);
             }
 
-            this.processEventsForNotifs(room, timelineEvents);
+            this.processEventsForNotifs(room, events);
 
             const processRoomEvent = async (e) => {
                 client.emit("event", e);
@@ -1320,6 +1349,7 @@ export class SyncApi {
 
             await utils.promiseMapSeries(stateEvents, processRoomEvent);
             await utils.promiseMapSeries(timelineEvents, processRoomEvent);
+            await utils.promiseMapSeries(threadedEvents, processRoomEvent);
             ephemeralEvents.forEach(function(e) {
                 client.emit("event", e);
             });
@@ -1339,10 +1369,13 @@ export class SyncApi {
         leaveRooms.forEach((leaveObj) => {
             const room = leaveObj.room;
             const stateEvents = this.mapSyncEventsFormat(leaveObj.state, room);
-            const timelineEvents = this.mapSyncEventsFormat(leaveObj.timeline, room);
+            const events = this.mapSyncEventsFormat(leaveObj.timeline, room);
             const accountDataEvents = this.mapSyncEventsFormat(leaveObj.account_data);
 
+            const [timelineEvents, threadedEvents] = this.partitionThreadedEvents(events);
+
             this.processRoomEvents(room, stateEvents, timelineEvents);
+            this.processThreadEvents(room, threadedEvents);
             room.addAccountData(accountDataEvents);
 
             room.recalculate();
@@ -1351,7 +1384,7 @@ export class SyncApi {
                 client.emit("Room", room);
             }
 
-            this.processEventsForNotifs(room, timelineEvents);
+            this.processEventsForNotifs(room, events);
 
             stateEvents.forEach(function(e) {
                 client.emit("event", e);
@@ -1359,6 +1392,9 @@ export class SyncApi {
             timelineEvents.forEach(function(e) {
                 client.emit("event", e);
             });
+            threadedEvents.forEach(function(e) {
+                client.emit("event", e);
+            });
             accountDataEvents.forEach(function(e) {
                 client.emit("event", e);
             });
@@ -1678,6 +1714,31 @@ export class SyncApi {
         room.addLiveEvents(timelineEventList || [], null, fromCache);
     }
 
+    /**
+     * @experimental
+     */
+    private processThreadEvents(room: Room, threadedEvents: MatrixEvent[]): void {
+        threadedEvents
+            .sort((a, b) => a.getTs() - b.getTs())
+            .forEach(event => {
+                room.addThreadedEvent(event);
+            });
+    }
+
+    // extractRelatedEvents(event: MatrixEvent, events: MatrixEvent[], relatedEvents: MatrixEvent[] = []): MatrixEvent[] {
+    //     relatedEvents.push(event);
+
+    //     const parentEventId = event.parentEventId;
+    //     const parentEventIndex = events.findIndex(event => event.getId() === parentEventId);
+
+    //     if (parentEventIndex > -1) {
+    //         const [relatedEvent] = events.splice(parentEventIndex, 1);
+    //         return this.extractRelatedEvents(relatedEvent, events, relatedEvents);
+    //     } else {
+    //         return relatedEvents;
+    //     }
+    // }
+
     /**
      * Takes a list of timelineEvents and adds and adds to notifEvents
      * as appropriate.

src/utils.ts

@@ -412,7 +412,7 @@ export function escapeRegExp(string: string): string {
     return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-export function globToRegexp(glob: string, extended: any): string {
+export function globToRegexp(glob: string, extended?: any): string {
     extended = typeof(extended) === 'boolean' ? extended : true;
     // From
     // https://github.com/matrix-org/synapse/blob/abbee6b29be80a77e05730707602f3bbfc3f38cb/synapse/push/__init__.py#L132
@@ -457,7 +457,7 @@ export interface IDeferred<T> {
 }
 
 // Returns a Deferred
-export function defer<T>(): IDeferred<T> {
+export function defer<T = void>(): IDeferred<T> {
     let resolve;
     let reject;
 

src/webrtc/call.ts

@@ -31,14 +31,21 @@ import { randomString } from '../randomstring';
 import {
     MCallReplacesEvent,
     MCallAnswer,
-    MCallOfferNegotiate,
+    MCallInviteNegotiate,
     CallCapabilities,
     SDPStreamMetadataPurpose,
     SDPStreamMetadata,
     SDPStreamMetadataKey,
     MCallSDPStreamMetadataChanged,
+    MCallSelectAnswer,
+    MCAllAssertedIdentity,
+    MCallCandidates,
+    MCallBase,
+    MCallHangupReject,
 } from './callEventTypes';
 import { CallFeed } from './callFeed';
+import { MatrixClient } from "../client";
+import { ISendEventResponse } from "../@types/requests";
 
 // events: hangup, error(err), replaced(call), state(state, oldState)
 
@@ -120,6 +127,8 @@ export enum CallEvent {
     FeedsChanged = 'feeds_changed',
 
     AssertedIdentityChanged = 'asserted_identity_changed',
+
+    LengthChanged = 'length_changed'
 }
 
 export enum CallErrorCode {
@@ -261,30 +270,33 @@ function genCallID(): string {
  * @param {MatrixClient} opts.client The Matrix Client instance to send events to.
  */
 export class MatrixCall extends EventEmitter {
-    roomId: string;
-    type: CallType;
-    callId: string;
-    state: CallState;
-    hangupParty: CallParty;
-    hangupReason: string;
-    direction: CallDirection;
-    ourPartyId: string;
+    public roomId: string;
+    public type: CallType = null;
+    public callId: string;
+    public state = CallState.Fledgling;
+    public hangupParty: CallParty;
+    public hangupReason: string;
+    public direction: CallDirection;
+    public ourPartyId: string;
 
-    private client: any; // Fix when client is TSified
+    private client: MatrixClient;
     private forceTURN: boolean;
     private turnServers: Array<TurnServer>;
-    private candidateSendQueue: Array<RTCIceCandidate>;
-    private candidateSendTries: number;
-    private sentEndOfCandidates: boolean;
+    // A queue for candidates waiting to go out.
+    // We try to amalgamate candidates into a single candidate message where
+    // possible
+    private candidateSendQueue: Array<RTCIceCandidate> = [];
+    private candidateSendTries = 0;
+    private sentEndOfCandidates = false;
     private peerConn: RTCPeerConnection;
-    private feeds: Array<CallFeed>;
-    private usermediaSenders: Array<RTCRtpSender>;
-    private screensharingSenders: Array<RTCRtpSender>;
-    private inviteOrAnswerSent: boolean;
+    private feeds: Array<CallFeed> = [];
+    private usermediaSenders: Array<RTCRtpSender> = [];
+    private screensharingSenders: Array<RTCRtpSender> = [];
+    private inviteOrAnswerSent = false;
     private waitForLocalAVStream: boolean;
     private successor: MatrixCall;
     private opponentMember: RoomMember;
-    private opponentVersion: number;
+    private opponentVersion: number | string;
     // The party ID of the other side: undefined if we haven't chosen a partner
     // yet, null if we have but they didn't send a party ID.
     private opponentPartyId: string;
@@ -293,7 +305,7 @@ export class MatrixCall extends EventEmitter {
 
     // The logic of when & if a call is on hold is nontrivial and explained in is*OnHold
     // This flag represents whether we want the other party to be on hold
-    private remoteOnHold;
+    private remoteOnHold = false;
 
     // the stats for the call at the point it ended. We can't get these after we
     // tear the call down, so we just grab a snapshot before we stop the call.
@@ -301,7 +313,7 @@ export class MatrixCall extends EventEmitter {
     private callStatsAtEnd: any[];
 
     // Perfect negotiation state: https://www.w3.org/TR/webrtc/#perfect-negotiation-example
-    private makingOffer: boolean;
+    private makingOffer = false;
     private ignoreOffer: boolean;
 
     // If candidates arrive before we've picked an opponent (which, in particular,
@@ -313,11 +325,13 @@ export class MatrixCall extends EventEmitter {
 
     private remoteSDPStreamMetadata: SDPStreamMetadata;
 
+    private callLengthInterval: number;
+    private callLength = 0;
+
     constructor(opts: CallOpts) {
         super();
         this.roomId = opts.roomId;
         this.client = opts.client;
-        this.type = null;
         this.forceTURN = opts.forceTURN;
         this.ourPartyId = this.client.deviceId;
         // Array of Objects with urls, username, credential keys
@@ -330,33 +344,14 @@ export class MatrixCall extends EventEmitter {
         for (const server of this.turnServers) {
             utils.checkObjectHasKeys(server, ["urls"]);
         }
-
         this.callId = genCallID();
-        this.state = CallState.Fledgling;
-
-        // A queue for candidates waiting to go out.
-        // We try to amalgamate candidates into a single candidate message where
-        // possible
-        this.candidateSendQueue = [];
-        this.candidateSendTries = 0;
-
-        this.sentEndOfCandidates = false;
-        this.inviteOrAnswerSent = false;
-        this.makingOffer = false;
-
-        this.remoteOnHold = false;
-
-        this.feeds = [];
-
-        this.usermediaSenders = [];
-        this.screensharingSenders = [];
     }
 
     /**
      * Place a voice call to this room.
      * @throws If you have not specified a listener for 'error' events.
      */
-    async placeVoiceCall() {
+    public async placeVoiceCall(): Promise<void> {
         logger.debug("placeVoiceCall");
         this.checkForErrorListener();
         const constraints = getUserMediaContraints(ConstraintsType.Audio);
@@ -368,7 +363,7 @@ export class MatrixCall extends EventEmitter {
      * Place a video call to this room.
      * @throws If you have not specified a listener for 'error' events.
      */
-    async placeVideoCall() {
+    public async placeVideoCall(): Promise<void> {
         logger.debug("placeVideoCall");
         this.checkForErrorListener();
         const constraints = getUserMediaContraints(ConstraintsType.Video);
@@ -376,11 +371,11 @@ export class MatrixCall extends EventEmitter {
         await this.placeCallWithConstraints(constraints);
     }
 
-    public getOpponentMember() {
+    public getOpponentMember(): RoomMember {
         return this.opponentMember;
     }
 
-    public opponentCanBeTransferred() {
+    public opponentCanBeTransferred(): boolean {
         return Boolean(this.opponentCaps && this.opponentCaps["m.call.transferee"]);
     }
 
@@ -462,7 +457,7 @@ export class MatrixCall extends EventEmitter {
         return !this.feeds.some((feed) => !feed.isLocal());
     }
 
-    private pushRemoteFeed(stream: MediaStream) {
+    private pushRemoteFeed(stream: MediaStream): void {
         // Fallback to old behavior if the other side doesn't support SDPStreamMetadata
         if (!this.opponentSupportsSDPStreamMetadata()) {
             this.pushRemoteFeedWithoutMetadata(stream);
@@ -495,7 +490,7 @@ export class MatrixCall extends EventEmitter {
     /**
      * This method is used ONLY if the other client doesn't support sending SDPStreamMetadata
      */
-    private pushRemoteFeedWithoutMetadata(stream: MediaStream) {
+    private pushRemoteFeedWithoutMetadata(stream: MediaStream): void {
         const userId = this.getOpponentMember().userId;
         // We can guess the purpose here since the other client can only send one stream
         const purpose = SDPStreamMetadataPurpose.Usermedia;
@@ -523,7 +518,7 @@ export class MatrixCall extends EventEmitter {
         logger.info(`Pushed remote stream (id="${stream.id}", active="${stream.active}")`);
     }
 
-    private pushLocalFeed(stream: MediaStream, purpose: SDPStreamMetadataPurpose, addToPeerConnection = true) {
+    private pushLocalFeed(stream: MediaStream, purpose: SDPStreamMetadataPurpose, addToPeerConnection = true): void {
         const userId = this.client.getUserId();
 
         // We try to replace an existing feed if there already is one with the same purpose
@@ -535,6 +530,7 @@ export class MatrixCall extends EventEmitter {
             this.emit(CallEvent.FeedsChanged, this.feeds);
         }
 
+        // TODO: Find out what is going on here
         // why do we enable audio (and only audio) tracks here? -- matthew
         setTracksEnabled(stream.getAudioTracks(), true);
 
@@ -561,12 +557,12 @@ export class MatrixCall extends EventEmitter {
         logger.info(`Pushed local stream (id="${stream.id}", active="${stream.active}", purpose="${purpose}")`);
     }
 
-    private deleteAllFeeds() {
+    private deleteAllFeeds(): void {
         this.feeds = [];
         this.emit(CallEvent.FeedsChanged, this.feeds);
     }
 
-    private deleteFeedByStream(stream: MediaStream) {
+    private deleteFeedByStream(stream: MediaStream): void {
         logger.debug(`Removing feed with stream id ${stream.id}`);
 
         const feed = this.getFeedByStreamId(stream.id);
@@ -606,8 +602,8 @@ export class MatrixCall extends EventEmitter {
      * Configure this call from an invite event. Used by MatrixClient.
      * @param {MatrixEvent} event The m.call.invite event
      */
-    async initWithInvite(event: MatrixEvent) {
-        const invite = event.getContent();
+    public async initWithInvite(event: MatrixEvent): Promise<void> {
+        const invite = event.getContent<MCallInviteNegotiate>();
         this.direction = CallDirection.Inbound;
 
         // make sure we have valid turn creds. Unless something's gone wrong, it should
@@ -673,7 +669,7 @@ export class MatrixCall extends EventEmitter {
      * Configure this call from a hangup or reject event. Used by MatrixClient.
      * @param {MatrixEvent} event The m.call.hangup event
      */
-    initWithHangup(event: MatrixEvent) {
+    public initWithHangup(event: MatrixEvent): void {
         // perverse as it may seem, sometimes we want to instantiate a call with a
         // hangup message (because when getting the state of the room on load, events
         // come in reverse order and we want to remember that a call has been hung up)
@@ -683,7 +679,7 @@ export class MatrixCall extends EventEmitter {
     /**
      * Answer a call.
      */
-    async answer() {
+    public async answer(): Promise<void> {
         if (this.inviteOrAnswerSent) {
             return;
         }
@@ -708,8 +704,6 @@ export class MatrixCall extends EventEmitter {
                 this.getUserMediaFailed(e);
                 return;
             }
-        } else if (this.localUsermediaStream) {
-            this.gotUserMediaForAnswer(this.localUsermediaStream);
         } else if (this.waitForLocalAVStream) {
             this.setState(CallState.WaitLocalMedia);
         }
@@ -720,15 +714,11 @@ export class MatrixCall extends EventEmitter {
      * MatrixClient.
      * @param {MatrixCall} newCall The new call.
      */
-    replacedBy(newCall: MatrixCall) {
-        logger.debug(this.callId + " being replaced by " + newCall.callId);
+    public replacedBy(newCall: MatrixCall): void {
         if (this.state === CallState.WaitLocalMedia) {
             logger.debug("Telling new call to wait for local media");
             newCall.waitForLocalAVStream = true;
-        } else if (this.state === CallState.CreateOffer) {
-            logger.debug("Handing local stream to new call");
-            newCall.gotUserMediaForAnswer(this.localUsermediaStream);
-        } else if (this.state === CallState.InviteSent) {
+        } else if ([CallState.CreateOffer, CallState.InviteSent].includes(this.state)) {
             logger.debug("Handing local stream to new call");
             newCall.gotUserMediaForAnswer(this.localUsermediaStream);
         }
@@ -742,7 +732,7 @@ export class MatrixCall extends EventEmitter {
      * @param {string} reason The reason why the call is being hung up.
      * @param {boolean} suppressEvent True to suppress emitting an event.
      */
-    hangup(reason: CallErrorCode, suppressEvent: boolean) {
+    public hangup(reason: CallErrorCode, suppressEvent: boolean): void {
         if (this.callHasEnded()) return;
 
         logger.debug("Ending call " + this.callId);
@@ -762,7 +752,7 @@ export class MatrixCall extends EventEmitter {
      * This used to be done by calling hangup, but is a separate method and protocol
      * event as of MSC2746.
      */
-    reject() {
+    public reject(): void {
         if (this.state !== CallState.Ringing) {
             throw Error("Call must be in 'ringing' state to reject!");
         }
@@ -805,7 +795,7 @@ export class MatrixCall extends EventEmitter {
     public async setScreensharingEnabled(
         enabled: boolean,
         selectDesktopCapturerSource?: () => Promise<DesktopCapturerSource>,
-    ) {
+    ): Promise<boolean> {
         // Skip if there is nothing to do
         if (enabled && this.isScreensharing()) {
             logger.warn(`There is already a screensharing stream - there is nothing to do!`);
@@ -855,7 +845,7 @@ export class MatrixCall extends EventEmitter {
     private async setScreensharingEnabledWithoutMetadataSupport(
         enabled: boolean,
         selectDesktopCapturerSource?: () => Promise<DesktopCapturerSource>,
-    ) {
+    ): Promise<boolean> {
         logger.debug(`Set screensharing enabled? ${enabled} using replaceTrack()`);
         if (enabled) {
             try {
@@ -901,7 +891,7 @@ export class MatrixCall extends EventEmitter {
      * Set whether our outbound video should be muted or not.
      * @param {boolean} muted True to mute the outbound video.
      */
-    setLocalVideoMuted(muted: boolean) {
+    public setLocalVideoMuted(muted: boolean): void {
         this.localUsermediaFeed?.setVideoMuted(muted);
         this.updateMuteStatus();
     }
@@ -915,7 +905,7 @@ export class MatrixCall extends EventEmitter {
      * @return {Boolean} True if the local preview video is muted, else false
      * (including if the call is not set up yet).
      */
-    isLocalVideoMuted(): boolean {
+    public isLocalVideoMuted(): boolean {
         return this.localUsermediaFeed?.isVideoMuted();
     }
 
@@ -923,7 +913,7 @@ export class MatrixCall extends EventEmitter {
      * Set whether the microphone should be muted or not.
      * @param {boolean} muted True to mute the mic.
      */
-    setMicrophoneMuted(muted: boolean) {
+    public setMicrophoneMuted(muted: boolean): void {
         this.localUsermediaFeed?.setAudioMuted(muted);
         this.updateMuteStatus();
     }
@@ -937,7 +927,7 @@ export class MatrixCall extends EventEmitter {
      * @return {Boolean} True if the mic is muted, else false (including if the call
      * is not set up yet).
      */
-    isMicrophoneMuted(): boolean {
+    public isMicrophoneMuted(): boolean {
         return this.localUsermediaFeed?.isAudioMuted();
     }
 
@@ -945,11 +935,11 @@ export class MatrixCall extends EventEmitter {
      * @returns true if we have put the party on the other side of the call on hold
      * (that is, we are signalling to them that we are not listening)
      */
-    isRemoteOnHold(): boolean {
+    public isRemoteOnHold(): boolean {
         return this.remoteOnHold;
     }
 
-    setRemoteOnHold(onHold: boolean) {
+    public setRemoteOnHold(onHold: boolean): void {
         if (this.isRemoteOnHold() === onHold) return;
         this.remoteOnHold = onHold;
 
@@ -969,7 +959,7 @@ export class MatrixCall extends EventEmitter {
      * they cannot hear us).
      * @returns true if the other party has put us on hold
      */
-    isLocalOnHold(): boolean {
+    public isLocalOnHold(): boolean {
         if (this.state !== CallState.Connected) return false;
 
         let callOnHold = true;
@@ -989,7 +979,7 @@ export class MatrixCall extends EventEmitter {
      * Sends a DTMF digit to the other party
      * @param digit The digit (nb. string - '#' and '*' are dtmf too)
      */
-    sendDtmfDigit(digit: string) {
+    public sendDtmfDigit(digit: string): void {
         for (const sender of this.peerConn.getSenders()) {
             if (sender.track.kind === 'audio' && sender.dtmf) {
                 sender.dtmf.insertDTMF(digit);
@@ -1000,7 +990,7 @@ export class MatrixCall extends EventEmitter {
         throw new Error("Unable to find a track to send DTMF on");
     }
 
-    private updateMuteStatus() {
+    private updateMuteStatus(): void {
         this.sendVoipEvent(EventType.CallSDPStreamMetadataChangedPrefix, {
             [SDPStreamMetadataKey]: this.getLocalSDPStreamMetadata(),
         });
@@ -1016,7 +1006,7 @@ export class MatrixCall extends EventEmitter {
      * Internal
      * @param {Object} stream
      */
-    private gotUserMediaForInvite = async (stream: MediaStream) => {
+    private gotUserMediaForInvite = async (stream: MediaStream): Promise<void> => {
         if (this.successor) {
             this.successor.gotUserMediaForAnswer(stream);
             return;
@@ -1029,12 +1019,11 @@ export class MatrixCall extends EventEmitter {
         this.pushLocalFeed(stream, SDPStreamMetadataPurpose.Usermedia);
         this.setState(CallState.CreateOffer);
 
-        logger.info("Got local AV stream with id " + this.localUsermediaStream.id);
         logger.debug("gotUserMediaForInvite -> " + this.type);
         // Now we wait for the negotiationneeded event
     };
 
-    private async sendAnswer() {
+    private async sendAnswer(): Promise<void> {
         const answerContent = {
             answer: {
                 sdp: this.peerConn.localDescription.sdp,
@@ -1081,15 +1070,12 @@ export class MatrixCall extends EventEmitter {
         this.sendCandidateQueue();
     }
 
-    private gotUserMediaForAnswer = async (stream: MediaStream) => {
+    private gotUserMediaForAnswer = async (stream: MediaStream): Promise<void> => {
         if (this.callHasEnded()) {
             return;
         }
 
         this.pushLocalFeed(stream, SDPStreamMetadataPurpose.Usermedia);
-
-        logger.info("Got local AV stream with id " + this.localUsermediaStream.id);
-
         this.setState(CallState.CreateAnswer);
 
         let myAnswer;
@@ -1123,7 +1109,7 @@ export class MatrixCall extends EventEmitter {
      * Internal
      * @param {Object} event
      */
-    private gotLocalIceCandidate = (event: RTCPeerConnectionIceEvent) => {
+    private gotLocalIceCandidate = (event: RTCPeerConnectionIceEvent): Promise<void> => {
         if (event.candidate) {
             logger.debug(
                 "Call " + this.callId + " got local ICE " + event.candidate.sdpMid + " candidate: " +
@@ -1142,7 +1128,7 @@ export class MatrixCall extends EventEmitter {
         }
     };
 
-    private onIceGatheringStateChange = (event: Event) => {
+    private onIceGatheringStateChange = (event: Event): void => {
         logger.debug("ice gathering state changed to " + this.peerConn.iceGatheringState);
         if (this.peerConn.iceGatheringState === 'complete' && !this.sentEndOfCandidates) {
             // If we didn't get an empty-string candidate to signal the end of candidates,
@@ -1160,19 +1146,20 @@ export class MatrixCall extends EventEmitter {
         }
     };
 
-    async onRemoteIceCandidatesReceived(ev: MatrixEvent) {
+    public async onRemoteIceCandidatesReceived(ev: MatrixEvent): Promise<void> {
         if (this.callHasEnded()) {
             //debuglog("Ignoring remote ICE candidate because call has ended");
             return;
         }
 
-        const candidates = ev.getContent().candidates;
+        const content = ev.getContent<MCallCandidates>();
+        const candidates = content.candidates;
         if (!candidates) {
             logger.info("Ignoring candidates event with no candidates!");
             return;
         }
 
-        const fromPartyId = ev.getContent().version === 0 ? null : ev.getContent().party_id || null;
+        const fromPartyId = content.version === 0 ? null : content.party_id || null;
 
         if (this.opponentPartyId === undefined) {
             // we haven't picked an opponent yet so save the candidates
@@ -1183,9 +1170,9 @@ export class MatrixCall extends EventEmitter {
             return;
         }
 
-        if (!this.partyIdMatches(ev.getContent())) {
+        if (!this.partyIdMatches(content)) {
             logger.info(
-                `Ignoring candidates from party ID ${ev.getContent().party_id}: ` +
+                `Ignoring candidates from party ID ${content.party_id}: ` +
                 `we have chosen party ID ${this.opponentPartyId}`,
             );
 
@@ -1199,8 +1186,9 @@ export class MatrixCall extends EventEmitter {
      * Used by MatrixClient.
      * @param {Object} msg
      */
-    async onAnswerReceived(event: MatrixEvent) {
-        logger.debug(`Got answer for call ID ${this.callId} from party ID ${event.getContent().party_id}`);
+    public async onAnswerReceived(event: MatrixEvent): Promise<void> {
+        const content = event.getContent<MCallAnswer>();
+        logger.debug(`Got answer for call ID ${this.callId} from party ID ${content.party_id}`);
 
         if (this.callHasEnded()) {
             logger.debug(`Ignoring answer because call ID ${this.callId} has ended`);
@@ -1209,7 +1197,7 @@ export class MatrixCall extends EventEmitter {
 
         if (this.opponentPartyId !== undefined) {
             logger.info(
-                `Ignoring answer from party ID ${event.getContent().party_id}: ` +
+                `Ignoring answer from party ID ${content.party_id}: ` +
                 `we already have an answer/reject from ${this.opponentPartyId}`,
             );
             return;
@@ -1220,7 +1208,7 @@ export class MatrixCall extends EventEmitter {
 
         this.setState(CallState.Connecting);
 
-        const sdpStreamMetadata = event.getContent()[SDPStreamMetadataKey];
+        const sdpStreamMetadata = content[SDPStreamMetadataKey];
         if (sdpStreamMetadata) {
             this.updateRemoteSDPStreamMetadata(sdpStreamMetadata);
         } else {
@@ -1228,7 +1216,7 @@ export class MatrixCall extends EventEmitter {
         }
 
         try {
-            await this.peerConn.setRemoteDescription(event.getContent().answer);
+            await this.peerConn.setRemoteDescription(content.answer);
         } catch (e) {
             logger.debug("Failed to set remote description", e);
             this.terminate(CallParty.Local, CallErrorCode.SetRemoteDescription, false);
@@ -1251,13 +1239,13 @@ export class MatrixCall extends EventEmitter {
         }
     }
 
-    async onSelectAnswerReceived(event: MatrixEvent) {
+    public async onSelectAnswerReceived(event: MatrixEvent): Promise<void> {
         if (this.direction !== CallDirection.Inbound) {
             logger.warn("Got select_answer for an outbound call: ignoring");
             return;
         }
 
-        const selectedPartyId = event.getContent().selected_party_id;
+        const selectedPartyId = event.getContent<MCallSelectAnswer>().selected_party_id;
 
         if (selectedPartyId === undefined || selectedPartyId === null) {
             logger.warn("Got nonsensical select_answer with null/undefined selected_party_id: ignoring");
@@ -1271,8 +1259,9 @@ export class MatrixCall extends EventEmitter {
         }
     }
 
-    async onNegotiateReceived(event: MatrixEvent) {
-        const description = event.getContent().description;
+    public async onNegotiateReceived(event: MatrixEvent): Promise<void> {
+        const content = event.getContent<MCallInviteNegotiate>();
+        const description = content.description;
         if (!description || !description.sdp || !description.type) {
             logger.info("Ignoring invalid m.call.negotiate event");
             return;
@@ -1286,7 +1275,7 @@ export class MatrixCall extends EventEmitter {
         // https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Perfect_negotiation
         const offerCollision = (
             (description.type === 'offer') &&
-            (this.makingOffer || this.peerConn.signalingState != 'stable')
+            (this.makingOffer || this.peerConn.signalingState !== 'stable')
         );
 
         this.ignoreOffer = !polite && offerCollision;
@@ -1297,7 +1286,7 @@ export class MatrixCall extends EventEmitter {
 
         const prevLocalOnHold = this.isLocalOnHold();
 
-        const sdpStreamMetadata = event.getContent()[SDPStreamMetadataKey];
+        const sdpStreamMetadata = content[SDPStreamMetadataKey];
         if (sdpStreamMetadata) {
             this.updateRemoteSDPStreamMetadata(sdpStreamMetadata);
         } else {
@@ -1345,12 +1334,13 @@ export class MatrixCall extends EventEmitter {
         this.updateRemoteSDPStreamMetadata(metadata);
     }
 
-    async onAssertedIdentityReceived(event: MatrixEvent) {
-        if (!event.getContent().asserted_identity) return;
+    public async onAssertedIdentityReceived(event: MatrixEvent): Promise<void> {
+        const content = event.getContent<MCAllAssertedIdentity>();
+        if (!content.asserted_identity) return;
 
         this.remoteAssertedIdentity = {
-            id: event.getContent().asserted_identity.id,
-            displayName: event.getContent().asserted_identity.display_name,
+            id: content.asserted_identity.id,
+            displayName: content.asserted_identity.display_name,
         };
         this.emit(CallEvent.AssertedIdentityChanged);
     }
@@ -1362,7 +1352,7 @@ export class MatrixCall extends EventEmitter {
         return this.state === CallState.Ended;
     }
 
-    private gotLocalOffer = async (description: RTCSessionDescriptionInit) => {
+    private gotLocalOffer = async (description: RTCSessionDescriptionInit): Promise<void> => {
         logger.debug("Created offer: ", description);
 
         if (this.callHasEnded()) {
@@ -1392,7 +1382,7 @@ export class MatrixCall extends EventEmitter {
 
         const content = {
             lifetime: CALL_TIMEOUT_MS,
-        } as MCallOfferNegotiate;
+        } as MCallInviteNegotiate;
 
         // clunky because TypeScript can't follow the types through if we use an expression as the key
         if (this.state === CallState.CreateOffer) {
@@ -1451,7 +1441,7 @@ export class MatrixCall extends EventEmitter {
         }
     };
 
-    private getLocalOfferFailed = (err: Error) => {
+    private getLocalOfferFailed = (err: Error): void => {
         logger.error("Failed to get local offer", err);
 
         this.emit(
@@ -1464,7 +1454,7 @@ export class MatrixCall extends EventEmitter {
         this.terminate(CallParty.Local, CallErrorCode.LocalOfferFailed, false);
     };
 
-    private getUserMediaFailed = (err: Error) => {
+    private getUserMediaFailed = (err: Error): void => {
         if (this.successor) {
             this.successor.getUserMediaFailed(err);
             return;
@@ -1483,7 +1473,7 @@ export class MatrixCall extends EventEmitter {
         this.terminate(CallParty.Local, CallErrorCode.NoUserMedia, false);
     };
 
-    onIceConnectionStateChanged = () => {
+    private onIceConnectionStateChanged = (): void => {
         if (this.callHasEnded()) {
             return; // because ICE can still complete as we're ending the call
         }
@@ -1494,19 +1484,23 @@ export class MatrixCall extends EventEmitter {
         // chrome doesn't implement any of the 'onstarted' events yet
         if (this.peerConn.iceConnectionState == 'connected') {
             this.setState(CallState.Connected);
+            this.callLengthInterval = setInterval(() => {
+                this.callLength++;
+                this.emit(CallEvent.LengthChanged, this.callLength);
+            }, 1000);
         } else if (this.peerConn.iceConnectionState == 'failed') {
             this.hangup(CallErrorCode.IceFailed, false);
         }
     };
 
-    private onSignallingStateChanged = () => {
+    private onSignallingStateChanged = (): void => {
         logger.debug(
             "call " + this.callId + ": Signalling state changed to: " +
             this.peerConn.signalingState,
         );
     };
 
-    private onTrack = (ev: RTCTrackEvent) => {
+    private onTrack = (ev: RTCTrackEvent): void => {
         if (ev.streams.length === 0) {
             logger.warn(`Streamless ${ev.track.kind} found: ignoring.`);
             return;
@@ -1530,7 +1524,7 @@ export class MatrixCall extends EventEmitter {
      *       [96685:23:0518/162603.933377:ERROR:webrtc_video_engine.cc(1171)] GetChangedRecvParameters called without any video codecs.
      *       [96685:23:0518/162603.933430:ERROR:sdp_offer_answer.cc(4302)] Failed to set local video description recv parameters for m-section with mid='2'. (INVALID_PARAMETER)
      */
-    private getRidOfRTXCodecs() {
+    private getRidOfRTXCodecs(): void {
         // RTCRtpReceiver.getCapabilities and RTCRtpSender.getCapabilities don't seem to be supported on FF
         if (!RTCRtpReceiver.getCapabilities || !RTCRtpSender.getCapabilities) return;
 
@@ -1558,7 +1552,7 @@ export class MatrixCall extends EventEmitter {
         }
     }
 
-    onNegotiationNeeded = async () => {
+    private onNegotiationNeeded = async (): Promise<void> => {
         logger.info("Negotiation is needed!");
 
         if (this.state !== CallState.CreateOffer && this.opponentVersion === 0) {
@@ -1579,7 +1573,7 @@ export class MatrixCall extends EventEmitter {
         }
     };
 
-    onHangupReceived = (msg) => {
+    public onHangupReceived = (msg: MCallHangupReject): void => {
         logger.debug("Hangup received for call ID " + this.callId);
 
         // party ID must match (our chosen partner hanging up the call) or be undefined (we haven't chosen
@@ -1592,7 +1586,7 @@ export class MatrixCall extends EventEmitter {
         }
     };
 
-    onRejectReceived = (msg) => {
+    public onRejectReceived = (msg: MCallHangupReject): void => {
         logger.debug("Reject received for call ID " + this.callId);
 
         // No need to check party_id for reject because if we'd received either
@@ -1614,12 +1608,12 @@ export class MatrixCall extends EventEmitter {
         }
     };
 
-    onAnsweredElsewhere = (msg) => {
+    public onAnsweredElsewhere = (msg: MCallAnswer): void => {
         logger.debug("Call ID " + this.callId + " answered elsewhere");
         this.terminate(CallParty.Remote, CallErrorCode.AnsweredElsewhere, true);
     };
 
-    setState(state: CallState) {
+    private setState(state: CallState): void {
         const oldState = this.state;
         this.state = state;
         this.emit(CallEvent.State, state, oldState);
@@ -1631,7 +1625,7 @@ export class MatrixCall extends EventEmitter {
      * @param {Object} content
      * @return {Promise}
      */
-    private sendVoipEvent(eventType: string, content: object) {
+    private sendVoipEvent(eventType: string, content: object): Promise<ISendEventResponse> {
         return this.client.sendEvent(this.roomId, eventType, Object.assign({}, content, {
             version: VOIP_PROTO_VERSION,
             call_id: this.callId,
@@ -1639,7 +1633,7 @@ export class MatrixCall extends EventEmitter {
         }));
     }
 
-    queueCandidate(content: RTCIceCandidate) {
+    private queueCandidate(content: RTCIceCandidate): void {
         // We partially de-trickle candidates by waiting for `delay` before sending them
         // amalgamated, in order to avoid sending too many m.call.candidates events and hitting
         // rate limits in Matrix.
@@ -1673,7 +1667,7 @@ export class MatrixCall extends EventEmitter {
     /*
      * Transfers this call to another user
      */
-    async transfer(targetUserId: string) {
+    public async transfer(targetUserId: string): Promise<void> {
         // Fetch the target user's global profile info: their room avatar / displayname
         // could be different in whatever room we share with them.
         const profileInfo = await this.client.getProfileInfo(targetUserId);
@@ -1684,7 +1678,7 @@ export class MatrixCall extends EventEmitter {
             replacement_id: genCallID(),
             target_user: {
                 id: targetUserId,
-                display_name: profileInfo.display_name,
+                display_name: profileInfo.displayname,
                 avatar_url: profileInfo.avatar_url,
             },
             create_call: replacementId,
@@ -1699,7 +1693,7 @@ export class MatrixCall extends EventEmitter {
      * 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) {
+    public async transferToCall(transferTargetCall?: MatrixCall): Promise<void> {
         const targetProfileInfo = await this.client.getProfileInfo(transferTargetCall.getOpponentMember().userId);
         const transfereeProfileInfo = await this.client.getProfileInfo(this.getOpponentMember().userId);
 
@@ -1711,7 +1705,7 @@ export class MatrixCall extends EventEmitter {
             replacement_id: genCallID(),
             target_user: {
                 id: this.getOpponentMember().userId,
-                display_name: transfereeProfileInfo.display_name,
+                display_name: transfereeProfileInfo.displayname,
                 avatar_url: transfereeProfileInfo.avatar_url,
             },
             await_call: newCallId,
@@ -1723,7 +1717,7 @@ export class MatrixCall extends EventEmitter {
             replacement_id: genCallID(),
             target_user: {
                 id: transferTargetCall.getOpponentMember().userId,
-                display_name: targetProfileInfo.display_name,
+                display_name: targetProfileInfo.displayname,
                 avatar_url: targetProfileInfo.avatar_url,
             },
             create_call: newCallId,
@@ -1735,7 +1729,7 @@ export class MatrixCall extends EventEmitter {
         await transferTargetCall.terminate(CallParty.Local, CallErrorCode.Transfered, true);
     }
 
-    private async terminate(hangupParty: CallParty, hangupReason: CallErrorCode, shouldEmit: boolean) {
+    private async terminate(hangupParty: CallParty, hangupReason: CallErrorCode, shouldEmit: boolean): Promise<void> {
         if (this.callHasEnded()) return;
 
         this.callStatsAtEnd = await this.collectCallStats();
@@ -1744,6 +1738,10 @@ export class MatrixCall extends EventEmitter {
             clearTimeout(this.inviteTimeout);
             this.inviteTimeout = null;
         }
+        if (this.callLengthInterval) {
+            clearInterval(this.callLengthInterval);
+            this.callLengthInterval = null;
+        }
 
         // Order is important here: first we stopAllMedia() and only then we can deleteAllFeeds()
         // We don't stop media if the call was replaced as we want to re-use streams in the successor
@@ -1761,7 +1759,7 @@ export class MatrixCall extends EventEmitter {
         }
     }
 
-    private stopAllMedia() {
+    private stopAllMedia(): void {
         logger.debug(`stopAllMedia (stream=${this.localUsermediaStream})`);
 
         for (const feed of this.feeds) {
@@ -1771,7 +1769,7 @@ export class MatrixCall extends EventEmitter {
         }
     }
 
-    private checkForErrorListener() {
+    private checkForErrorListener(): void {
         if (this.listeners("error").length === 0) {
             throw new Error(
                 "You MUST attach an error listener using call.on('error', function() {})",
@@ -1779,7 +1777,7 @@ export class MatrixCall extends EventEmitter {
         }
     }
 
-    private async sendCandidateQueue() {
+    private async sendCandidateQueue(): Promise<void> {
         if (this.candidateSendQueue.length === 0) {
             return;
         }
@@ -1828,7 +1826,7 @@ export class MatrixCall extends EventEmitter {
         }
     }
 
-    private async placeCallWithConstraints(constraints: MediaStreamConstraints) {
+    private async placeCallWithConstraints(constraints: MediaStreamConstraints): Promise<void> {
         logger.log("Getting user media with constraints", constraints);
         // XXX Find a better way to do this
         this.client.callEventHandler.calls.set(this.callId, this);
@@ -1873,7 +1871,7 @@ export class MatrixCall extends EventEmitter {
         return pc;
     }
 
-    private partyIdMatches(msg): boolean {
+    private partyIdMatches(msg: MCallBase): boolean {
         // They must either match or both be absent (in which case opponentPartyId will be null)
         // Also we ignore party IDs on the invite/offer if the version is 0, so we must do the same
         // here and use null if the version is 0 (woe betide any opponent sending messages in the
@@ -1884,9 +1882,9 @@ export class MatrixCall extends EventEmitter {
 
     // Commits to an opponent for the call
     // ev: An invite or answer event
-    private chooseOpponent(ev: MatrixEvent) {
+    private chooseOpponent(ev: MatrixEvent): void {
         // I choo-choo-choose you
-        const msg = ev.getContent();
+        const msg = ev.getContent<MCallInviteNegotiate | MCallAnswer>();
 
         logger.debug(`Choosing party ID ${msg.party_id} for call ID ${this.callId}`);
 
@@ -1901,11 +1899,11 @@ export class MatrixCall extends EventEmitter {
             // party ID
             this.opponentPartyId = msg.party_id || null;
         }
-        this.opponentCaps = msg.capabilities || {};
+        this.opponentCaps = msg.capabilities || {} as CallCapabilities;
         this.opponentMember = ev.sender;
     }
 
-    private async addBufferedIceCandidates() {
+    private async addBufferedIceCandidates(): Promise<void> {
         const bufferedCandidates = this.remoteCandidateBuffer.get(this.opponentPartyId);
         if (bufferedCandidates) {
             logger.info(`Adding ${bufferedCandidates.length} buffered candidates for opponent ${this.opponentPartyId}`);
@@ -1914,7 +1912,7 @@ export class MatrixCall extends EventEmitter {
         this.remoteCandidateBuffer = null;
     }
 
-    private async addIceCandidates(candidates: RTCIceCandidate[]) {
+    private async addIceCandidates(candidates: RTCIceCandidate[]): Promise<void> {
         for (const candidate of candidates) {
             if (
                 (candidate.sdpMid === null || candidate.sdpMid === undefined) &&
@@ -1935,6 +1933,10 @@ export class MatrixCall extends EventEmitter {
             }
         }
     }
+
+    public get hasPeerConnection(): boolean {
+        return Boolean(this.peerConn);
+    }
 }
 
 async function getScreensharingStream(
@@ -1954,13 +1956,13 @@ async function getScreensharingStream(
     }
 }
 
-function setTracksEnabled(tracks: Array<MediaStreamTrack>, enabled: boolean) {
+function setTracksEnabled(tracks: Array<MediaStreamTrack>, enabled: boolean): void {
     for (let i = 0; i < tracks.length; i++) {
         tracks[i].enabled = enabled;
     }
 }
 
-function getUserMediaContraints(type: ConstraintsType) {
+function getUserMediaContraints(type: ConstraintsType): MediaStreamConstraints {
     const isWebkit = !!navigator.webkitGetUserMedia;
 
     switch (type) {
@@ -1991,7 +1993,9 @@ function getUserMediaContraints(type: ConstraintsType) {
     }
 }
 
-async function getScreenshareContraints(selectDesktopCapturerSource?: () => Promise<DesktopCapturerSource>) {
+async function getScreenshareContraints(
+    selectDesktopCapturerSource?: () => Promise<DesktopCapturerSource>,
+): Promise<DesktopCapturerConstraints> {
     if (window.electron?.getDesktopCapturerSources && selectDesktopCapturerSource) {
         // We have access to getDesktopCapturerSources()
         logger.debug("Electron getDesktopCapturerSources() is available...");
@@ -2025,14 +2029,14 @@ let videoInput: string;
  * @param {string=} deviceId the identifier for the device
  * undefined treated as unset
  */
-export function setAudioInput(deviceId: string) { audioInput = deviceId; }
+export function setAudioInput(deviceId: string): void { audioInput = deviceId; }
 /**
  * Set a video input device to use for MatrixCalls
  * @function
  * @param {string=} deviceId the identifier for the device
  * undefined treated as unset
  */
-export function setVideoInput(deviceId: string) { videoInput = deviceId; }
+export function setVideoInput(deviceId: string): void { videoInput = deviceId; }
 
 /**
  * DEPRECATED
@@ -2047,7 +2051,7 @@ export function setVideoInput(deviceId: string) { videoInput = deviceId; }
  * since it's only possible to set this option on outbound calls.
  * @return {MatrixCall} the call or null if the browser doesn't support calling.
  */
-export function createNewMatrixCall(client: any, roomId: string, options?: CallOpts) {
+export function createNewMatrixCall(client: any, roomId: string, options?: CallOpts): MatrixCall {
     // typeof prevents Node from erroring on an undefined reference
     if (typeof(window) === 'undefined' || typeof(document) === 'undefined') {
         // NB. We don't log here as apps try to create a call object as a test for

src/webrtc/callEventHandler.ts

@@ -19,6 +19,7 @@ import { logger } from '../logger';
 import { createNewMatrixCall, MatrixCall, CallErrorCode, CallState, CallDirection } from './call';
 import { EventType } from '../@types/event';
 import { MatrixClient } from '../client';
+import { MCallAnswer, MCallHangupReject } from "./callEventTypes";
 
 // Don't ring unless we'd be ringing for at least 3 seconds: the user needs some
 // time to press the 'accept' button
@@ -80,7 +81,7 @@ export class CallEventHandler {
                     continue;
                 }
                 try {
-                    this.handleCallEvent(e);
+                    await this.handleCallEvent(e);
                 } catch (e) {
                     logger.error("Caught exception handling call event", e);
                 }
@@ -100,7 +101,7 @@ export class CallEventHandler {
 
         if (event.isBeingDecrypted() || event.isDecryptionFailure()) {
             // add an event listener for once the event is decrypted.
-            event.once("Event.decrypted", () => {
+            event.once("Event.decrypted", async () => {
                 if (!this.eventIsACall(event)) return;
 
                 if (this.callEventBuffer.includes(event)) {
@@ -110,7 +111,7 @@ export class CallEventHandler {
                     // This one wasn't buffered so just run the event handler for it
                     // straight away
                     try {
-                        this.handleCallEvent(event);
+                        await this.handleCallEvent(event);
                     } catch (e) {
                         logger.error("Caught exception handling call event", e);
                     }
@@ -128,7 +129,7 @@ export class CallEventHandler {
         return type.startsWith("m.call.") || type.startsWith("org.matrix.call.");
     }
 
-    private handleCallEvent(event: MatrixEvent) {
+    private async handleCallEvent(event: MatrixEvent) {
         const content = event.getContent();
         const type = event.getType() as EventType;
         const weSentTheEvent = event.getSender() === this.client.credentials.userId;
@@ -169,7 +170,7 @@ export class CallEventHandler {
             }
 
             call.callId = content.call_id;
-            call.initWithInvite(event);
+            await call.initWithInvite(event);
             this.calls.set(call.callId, call);
 
             // if we stashed candidate events for that call ID, play them back now
@@ -201,9 +202,11 @@ export class CallEventHandler {
                 // we've got an invite, pick the incoming call because we know
                 // we haven't sent our invite yet otherwise, pick whichever
                 // call has the lowest call ID (by string comparison)
-                if (existingCall.state === CallState.WaitLocalMedia ||
-                        existingCall.state === CallState.CreateOffer ||
-                        existingCall.callId > call.callId) {
+                if (
+                    existingCall.state === CallState.WaitLocalMedia ||
+                    existingCall.state === CallState.CreateOffer ||
+                    existingCall.callId > call.callId
+                ) {
                     logger.log(
                         "Glare detected: answering incoming call " + call.callId +
                         " and canceling outgoing call " + existingCall.callId,
@@ -220,6 +223,7 @@ export class CallEventHandler {
             } else {
                 this.client.emit("Call.incoming", call);
             }
+            return;
         } else if (type === EventType.CallCandidates) {
             if (weSentTheEvent) return;
 
@@ -232,6 +236,7 @@ export class CallEventHandler {
             } else {
                 call.onRemoteIceCandidatesReceived(event);
             }
+            return;
         } else if ([EventType.CallHangup, EventType.CallReject].includes(type)) {
             // Note that we also observe our own hangups here so we can see
             // if we've already rejected a call that would otherwise be valid
@@ -248,17 +253,21 @@ export class CallEventHandler {
             } else {
                 if (call.state !== CallState.Ended) {
                     if (type === EventType.CallHangup) {
-                        call.onHangupReceived(content);
+                        call.onHangupReceived(content as MCallHangupReject);
                     } else {
-                        call.onRejectReceived(content);
+                        call.onRejectReceived(content as MCallHangupReject);
                     }
                     this.calls.delete(content.call_id);
                 }
             }
+            return;
         }
 
-        // The following events need a call
-        if (!call) return;
+        // The following events need a call and a peer connection
+        if (!call || !call.hasPeerConnection) {
+            logger.warn("Discarding an event, we don't have a call/peerConn", type);
+            return;
+        }
         // Ignore remote echo
         if (event.getContent().party_id === call.ourPartyId) return;
 
@@ -266,7 +275,7 @@ export class CallEventHandler {
             case EventType.CallAnswer:
                 if (weSentTheEvent) {
                     if (call.state === CallState.Ringing) {
-                        call.onAnsweredElsewhere(content);
+                        call.onAnsweredElsewhere(content as MCallAnswer);
                     }
                 } else {
                     call.onAnswerReceived(event);

src/webrtc/callEventTypes.ts

@@ -1,6 +1,8 @@
 // allow non-camelcase as these are events type that go onto the wire
 /* eslint-disable camelcase */
 
+import { CallErrorCode } from "./call";
+
 // TODO: Change to "sdp_stream_metadata" when MSC3077 is merged
 export const SDPStreamMetadataKey = "org.matrix.msc3077.sdp_stream_metadata";
 
@@ -19,11 +21,6 @@ export interface SDPStreamMetadata {
     [key: string]: SDPStreamMetadataObject;
 }
 
-interface CallOfferAnswer {
-    type: string;
-    sdp: string;
-}
-
 export interface CallCapabilities {
     'm.call.transferee': boolean;
     'm.call.dtmf': boolean;
@@ -35,29 +32,56 @@ export interface CallReplacesTarget {
     avatar_url: string;
 }
 
-export interface MCallAnswer {
-    answer: CallOfferAnswer;
-    capabilities: CallCapabilities;
+export interface MCallBase {
+    call_id: string;
+    version: string | number;
+    party_id?: string;
+}
+
+export interface MCallAnswer extends MCallBase {
+    answer: RTCSessionDescription;
+    capabilities?: CallCapabilities;
     [SDPStreamMetadataKey]: SDPStreamMetadata;
 }
 
-export interface MCallOfferNegotiate {
-    offer: CallOfferAnswer;
-    description: CallOfferAnswer;
+export interface MCallSelectAnswer extends MCallBase {
+    selected_party_id: string;
+}
+
+export interface MCallInviteNegotiate extends MCallBase {
+    offer: RTCSessionDescription;
+    description: RTCSessionDescription;
     lifetime: number;
-    capabilities: CallCapabilities;
+    capabilities?: CallCapabilities;
     [SDPStreamMetadataKey]: SDPStreamMetadata;
 }
 
-export interface MCallSDPStreamMetadataChanged {
+export interface MCallSDPStreamMetadataChanged extends MCallBase {
     [SDPStreamMetadataKey]: SDPStreamMetadata;
 }
 
-export interface MCallReplacesEvent {
+export interface MCallReplacesEvent extends MCallBase {
     replacement_id: string;
     target_user: CallReplacesTarget;
     create_call: string;
     await_call: string;
     target_room: string;
 }
+
+export interface MCAllAssertedIdentity extends MCallBase {
+    asserted_identity: {
+        id: string;
+        display_name: string;
+        avatar_url: string;
+    };
+}
+
+export interface MCallCandidates extends MCallBase {
+    candidates: RTCIceCandidate[];
+}
+
+export interface MCallHangupReject extends MCallBase {
+    reason?: CallErrorCode;
+}
+
 /* eslint-enable camelcase */

src/webrtc/callFeed.ts

@@ -19,12 +19,24 @@ import { SDPStreamMetadataPurpose } from "./callEventTypes";
 import { MatrixClient } from "../client";
 import { RoomMember } from "../models/room-member";
 
+const POLLING_INTERVAL = 250; // ms
+const SPEAKING_THRESHOLD = -60; // dB
+
 export enum CallFeedEvent {
     NewStream = "new_stream",
-    MuteStateChanged = "mute_state_changed"
+    MuteStateChanged = "mute_state_changed",
+    VolumeChanged = "volume_changed",
+    Speaking = "speaking",
 }
 
 export class CallFeed extends EventEmitter {
+    private measuringVolumeActivity = false;
+    private audioContext: AudioContext;
+    private analyser: AnalyserNode;
+    private frequencyBinCount: Float32Array;
+    private speakingThreshold = SPEAKING_THRESHOLD;
+    private speaking = false;
+
     constructor(
         public stream: MediaStream,
         public userId: string,
@@ -35,6 +47,30 @@ export class CallFeed extends EventEmitter {
         private videoMuted: boolean,
     ) {
         super();
+
+        if (this.hasAudioTrack) {
+            this.initVolumeMeasuring();
+        }
+    }
+
+    private get hasAudioTrack(): boolean {
+        return this.stream.getAudioTracks().length > 0;
+    }
+
+    private initVolumeMeasuring(): void {
+        const AudioContext = window.AudioContext || window.webkitAudioContext;
+        if (!this.hasAudioTrack || !AudioContext) return;
+
+        this.audioContext = new AudioContext();
+
+        this.analyser = this.audioContext.createAnalyser();
+        this.analyser.fftSize = 512;
+        this.analyser.smoothingTimeConstant = 0.1;
+
+        const mediaStreamAudioSourceNode = this.audioContext.createMediaStreamSource(this.stream);
+        mediaStreamAudioSourceNode.connect(this.analyser);
+
+        this.frequencyBinCount = new Float32Array(this.analyser.frequencyBinCount);
     }
 
     /**
@@ -78,18 +114,78 @@ export class CallFeed extends EventEmitter {
      * This method should be only used by MatrixCall.
      * @param newStream new stream with which to replace the current one
      */
-    public setNewStream(newStream: MediaStream) {
+    public setNewStream(newStream: MediaStream): void {
         this.stream = newStream;
         this.emit(CallFeedEvent.NewStream, this.stream);
+
+        if (this.hasAudioTrack) {
+            this.initVolumeMeasuring();
+        } else {
+            this.measureVolumeActivity(false);
+        }
     }
 
+    /**
+     * Set feed's internal audio mute state
+     * @param muted is the feed's audio muted?
+     */
     public setAudioMuted(muted: boolean): void {
         this.audioMuted = muted;
         this.emit(CallFeedEvent.MuteStateChanged, this.audioMuted, this.videoMuted);
     }
 
+    /**
+     * Set feed's internal video mute state
+     * @param muted is the feed's video muted?
+     */
     public setVideoMuted(muted: boolean): void {
         this.videoMuted = muted;
         this.emit(CallFeedEvent.MuteStateChanged, this.audioMuted, this.videoMuted);
     }
+
+    /**
+     * Starts emitting volume_changed events where the emitter value is in decibels
+     * @param enabled emit volume changes
+     */
+    public measureVolumeActivity(enabled: boolean): void {
+        if (enabled) {
+            if (!this.audioContext || !this.analyser || !this.frequencyBinCount || !this.hasAudioTrack) return;
+
+            this.measuringVolumeActivity = true;
+            this.volumeLooper();
+        } else {
+            this.measuringVolumeActivity = false;
+            this.emit(CallFeedEvent.VolumeChanged, -Infinity);
+        }
+    }
+
+    public setSpeakingThreshold(threshold: number) {
+        this.speakingThreshold = threshold;
+    }
+
+    private volumeLooper(): void {
+        if (!this.analyser) return;
+
+        setTimeout(() => {
+            if (!this.measuringVolumeActivity) return;
+
+            this.analyser.getFloatFrequencyData(this.frequencyBinCount);
+
+            let maxVolume = -Infinity;
+            for (let i = 0; i < this.frequencyBinCount.length; i++) {
+                if (this.frequencyBinCount[i] > maxVolume) {
+                    maxVolume = this.frequencyBinCount[i];
+                }
+            }
+
+            this.emit(CallFeedEvent.VolumeChanged, maxVolume);
+            const newSpeaking = maxVolume > this.speakingThreshold;
+            if (this.speaking !== newSpeaking) {
+                this.speaking = newSpeaking;
+                this.emit(CallFeedEvent.Speaking, this.speaking);
+            }
+
+            this.volumeLooper();
+        }, POLLING_INTERVAL);
+    }
 }