v17.2.0

Prepare changelog for v17.2.0
v17.2.0-rc.1
2022-05-10 14:46:15 +01:00 · 2022-05-10 14:46:15 +01:00 · 2022-05-03 15:20:39 +01:00 · 2022-05-03 15:20:38 +01:00 · 2022-05-03 14:46:36 +01:00 · 2022-05-03 14:25:17 +01:00
60 changed files with 2210 additions and 996 deletions
@@ -21,3 +21,6 @@ insert_final_newline = true
 indent_style = space
 indent_size = 4
 trim_trailing_whitespace = true
+
+[*.{yml,yaml}]
+indent_size = 2
@@ -0,0 +1,41 @@
+# Minor white-space adjustments
+1d1d59c75744e1f6a2be1cb3e0d1bd9ded5f8025
+# Import ordering and spacing: eslint-plugin-import
+80aaa6c32b50601f82e0c991c24e5a4590f39463
+# Minor white-space adjustment
+8fb036ba2d01fab66dc4373802ccf19b5cac8541
+# Minor white-space adjustment
+b63de6a902a9e1f8ffd7697dea33820fc04f028e
+3ca84cfc491b0987eec1f13f13cae58d2032bf54
+# Conform to new typescript eslint rules
+a87858840b57514603f63e2abbbda4f107f05a77
+5cf6684129a921295f5593173f16f192336fe0a2
+# Comply with new member-delimiter-style rule
+b2ad957d298720d3e026b6bd91be0c403338361a
+# Fix semicolons in TS files
+e2ec8952e38b8fea3f0ccaa09ecb42feeba0d923
+# Migrate to `eslint-plugin-matrix-org`
+# and `babel/...` to `@babel/...` migration
+09fac77ce0d9bcf6637088c29afab84084f0e739
+102704e91a70643bcc09721e14b0d909f0ef55c6
+# Eslint formatting
+cec00cd303787fa9008b6c48826e75ed438036fa
+# Minor eslint changes
+68bb8182e4e62d8f450f80c408c4b231b8725f1b
+c979ff6696e30ab8983ac416a3590996d84d3560
+f4a7395e3a3751a1a8e92dd302c49175a3296ad2
+# eslint --fix for dangley commas on function calls
+423175f5397910b0afe3112d6fb18283fc7d27d4
+# eslint ---fix for prefer-const
+7bca05af644e8b997dae81e568a3913d8f18d7ca
+# Fix linting on tests
+cee7f7a280a8c20bafc21c0a2911f60851f7a7ca
+# eslint --fix
+0fa9f7c6098822db1ae214f352fd1fe5c248b02c
+# eslint --fix for lots of white-space
+5abf6b9f208801c5022a47023150b5846cb0b309
+# eslint --fix
+7ed65407e6cdf292ce3cf659310c68d19dcd52b2
+# Switch to ESLint from JSHint (Google eslint rules as a base)
+e057956ede9ad1a931ff8050c411aca7907e0394
+
@@ -1,12 +0,0 @@
-codecov:
-  allow_coverage_offsets: True
-coverage:
-  status:
-    project: off
-    patch: off
-comment:
-  layout: "diff, files"
-  behavior: default
-  require_changes: false
-  require_base: no
-  require_head: no
@@ -0,0 +1,14 @@
+name: Notify Downstream Projects
+on:
+  push:
+    branches: [ develop ]
+jobs:
+  notify-matrix-react-sdk:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Notify matrix-react-sdk repo that a new SDK build is on develop so it can CI against it
+        uses: peter-evans/repository-dispatch@v1
+        with:
+          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+          repository: vector-im/element-web
+          event-type: upstream-sdk-notify
@@ -1,12 +0,0 @@
-name: Preview Changelog
-on:
-  pull_request_target:
-    types: [ opened, edited, labeled ]
-jobs:
-    changelog:
-        runs-on: ubuntu-latest
-        steps:
-            - name: Preview Changelog
-              uses: matrix-org/allchange@main
-              with:
-                  ghToken: ${{ secrets.GITHUB_TOKEN }}
@@ -0,0 +1,24 @@
+name: Pull Request
+on:
+  pull_request_target:
+    types: [ opened, edited, labeled, unlabeled ]
+jobs:
+  changelog:
+    name: Preview Changelog
+    runs-on: ubuntu-latest
+    steps:
+      - uses: matrix-org/allchange@main
+        with:
+          ghToken: ${{ secrets.GITHUB_TOKEN }}
+
+  enforce-label:
+    name: Enforce Labels
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+    steps:
+      - uses: yogevbd/enforce-label-action@2.1.0
+        with:
+          REQUIRED_LABELS_ANY: "T-Defect,T-Deprecation,T-Enhancement,T-Task"
+          BANNED_LABELS: "X-Blocked"
+          BANNED_LABELS_DESCRIPTION: "Preventing merge whilst PR is marked blocked!"
@@ -0,0 +1,47 @@
+name: SonarQube
+on:
+  workflow_run:
+    workflows: [ "Tests" ]
+    types:
+      - completed
+jobs:
+  sonarqube:
+    name: SonarQube
+    runs-on: ubuntu-latest
+    if: github.event.workflow_run.conclusion == 'success'
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
+
+      # There's a 'download artifact' action, but it hasn't been updated for the workflow_run action
+      # (https://github.com/actions/download-artifact/issues/60) so instead we get this mess:
+      - name: Download Coverage Report
+        uses: actions/github-script@v3.1.0
+        with:
+          script: |
+            const artifacts = await github.actions.listWorkflowRunArtifacts({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                run_id: ${{ github.event.workflow_run.id }},
+            });
+            const matchArtifact = artifacts.data.artifacts.filter((artifact) => {
+                return artifact.name == "coverage"
+            })[0];
+            const download = await github.actions.downloadArtifact({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                artifact_id: matchArtifact.id,
+                archive_format: 'zip',
+            });
+            const fs = require('fs');
+            fs.writeFileSync('${{github.workspace}}/coverage.zip', Buffer.from(download.data));
+
+      - name: Extract Coverage Report
+        run: unzip -d coverage coverage.zip && rm coverage.zip
+
+      - name: SonarCloud Scan
+        uses: SonarSource/sonarcloud-github-action@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
@@ -0,0 +1,53 @@
+name: Static Analysis
+on:
+  pull_request: { }
+  push:
+    branches: [ develop, master ]
+jobs:
+  ts_lint:
+    name: "Typescript Syntax Check"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions/setup-node@v3
+        with:
+          cache: 'yarn'
+
+      - name: Install Deps
+        run: "yarn install"
+
+      - name: Typecheck
+        run: "yarn run lint:types"
+
+  js_lint:
+    name: "ESLint"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions/setup-node@v3
+        with:
+          cache: 'yarn'
+
+      - name: Install Deps
+        run: "yarn install"
+
+      - name: Run Linter
+        run: "yarn run lint:js"
+
+  docs:
+    name: "JSDoc Checker"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions/setup-node@v3
+        with:
+          cache: 'yarn'
+
+      - name: Install Deps
+        run: "yarn install"
+
+      - name: Generate Docs
+        run: "yarn run gendoc"
@@ -1,31 +0,0 @@
-name: Test coverage
-on:
-  pull_request: {}
-  push:
-    branches: [develop, main, master]
-jobs:
-  test-coverage:
-    runs-on: ubuntu-latest
-    env:
-      # This must be set for fetchdep.sh to get the right branch
-      PR_NUMBER: ${{github.event.number}}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-        with:
-          # If this is a pull request, make sure we check out its head rather than the
-          # automatically generated merge commit, so that the coverage diff excludes
-          # unrelated changes in the base branch
-          ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || '' }}
-
-      - name: Yarn cache
-        uses: c-hive/gha-yarn-cache@v2
-
-      - name: Run tests with coverage
-        run: "yarn install && yarn build && yarn coverage"
-
-      - name: Upload coverage
-        uses: codecov/codecov-action@v2
-        with:
-          fail_ci_if_error: false
-          verbose: true
@@ -0,0 +1,34 @@
+name: Tests
+on:
+  pull_request: { }
+  push:
+    branches: [ develop, main, master ]
+jobs:
+  jest:
+    name: Jest
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Yarn cache
+        uses: actions/setup-node@v3
+        with:
+          cache: 'yarn'
+
+      - name: Install dependencies
+        run: "yarn install"
+
+      - name: Build
+        run: "yarn build"
+
+      - name: Run tests with coverage
+        run: "yarn coverage --ci"
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: coverage
+          path: |
+            coverage
+            !coverage/lcov-report
@@ -1,11 +1,45 @@
-Changes in [17.0.0-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.0.0-rc.3) (2022-04-11)
-============================================================================================================
+Changes in [17.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.2.0) (2022-05-10)
+==================================================================================================

-Changes in [17.0.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.0.0-rc.2) (2022-04-08)
-============================================================================================================
+## ✨ Features
+ * Live location sharing: handle encrypted messages in processBeaconEvents ([\#2327](https://github.com/matrix-org/matrix-js-sdk/pull/2327)).

-Changes in [17.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.0.0-rc.1) (2022-04-08)
-============================================================================================================
+## 🐛 Bug Fixes
+ * Fix race conditions around threads ([\#2331](https://github.com/matrix-org/matrix-js-sdk/pull/2331)). Fixes vector-im/element-web#21627.
+ * Ignore m.replace relations on state events, they're invalid ([\#2306](https://github.com/matrix-org/matrix-js-sdk/pull/2306)). Fixes vector-im/element-web#21851.
+ * fix example in readme ([\#2315](https://github.com/matrix-org/matrix-js-sdk/pull/2315)).
+ * Don't decrement the length count of a thread when root redacted ([\#2314](https://github.com/matrix-org/matrix-js-sdk/pull/2314)).
+ * Prevent attempt to create thread with id "undefined" ([\#2308](https://github.com/matrix-org/matrix-js-sdk/pull/2308)).
+ * Update threads handling for replies-to-thread-responses as per MSC update ([\#2305](https://github.com/matrix-org/matrix-js-sdk/pull/2305)). Fixes vector-im/element-web#19678.
+
+Changes in [17.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.1.0) (2022-04-26)
+==================================================================================================
+
+## ✨ Features
+ * Add MatrixClient.doesServerSupportLogoutDevices() for MSC2457 ([\#2297](https://github.com/matrix-org/matrix-js-sdk/pull/2297)).
+ * Live location sharing - expose room liveBeaconIds ([\#2296](https://github.com/matrix-org/matrix-js-sdk/pull/2296)).
+ * Support for MSC2457 logout_devices param for setPassword() ([\#2285](https://github.com/matrix-org/matrix-js-sdk/pull/2285)).
+ * Stabilise token authenticated registration support ([\#2181](https://github.com/matrix-org/matrix-js-sdk/pull/2181)). Contributed by @govynnus.
+ * Live location sharing - Aggregate beacon locations on beacons ([\#2268](https://github.com/matrix-org/matrix-js-sdk/pull/2268)).
+
+## 🐛 Bug Fixes
+ * Prevent duplicated re-emitter setups in event-mapper ([\#2293](https://github.com/matrix-org/matrix-js-sdk/pull/2293)).
+ * Make self membership less prone to races ([\#2277](https://github.com/matrix-org/matrix-js-sdk/pull/2277)). Fixes vector-im/element-web#21661.
+
+Changes in [17.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.0.0) (2022-04-11)
+==================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Remove groups and groups-related APIs ([\#2234](https://github.com/matrix-org/matrix-js-sdk/pull/2234)).
+
+## ✨ Features
+ * Add Element video room type ([\#2273](https://github.com/matrix-org/matrix-js-sdk/pull/2273)).
+ * Live location sharing - handle redacted beacons ([\#2269](https://github.com/matrix-org/matrix-js-sdk/pull/2269)).
+
+## 🐛 Bug Fixes
+ * Fix getSessionsNeedingBackup() limit support ([\#2270](https://github.com/matrix-org/matrix-js-sdk/pull/2270)). Contributed by @adamvy.
+ * Fix issues with /search and /context API handling for threads ([\#2261](https://github.com/matrix-org/matrix-js-sdk/pull/2261)). Fixes vector-im/element-web#21543.
+ * Prevent exception 'Unable to set up secret storage' ([\#2260](https://github.com/matrix-org/matrix-js-sdk/pull/2260)).

 Changes in [16.0.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.2-rc.1) (2022-04-05)
 ============================================================================================================
@@ -664,7 +698,7 @@ Changes in [11.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/ta
 BREAKING CHANGES
 ---

- * `MatrixCall` and related APIs have been redesigned to support multiple streams 
+ * `MatrixCall` and related APIs have been redesigned to support multiple streams
   (see [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660) for more details)

 All changes
@@ -1337,7 +1371,7 @@ BREAKING CHANGES
 ---

 * `RoomState` events changed to use a Map instead of an object, which changes the collection APIs available to access them.
- 
+
 All Changes
 ---

@@ -243,3 +243,15 @@ on Git 2.17+ you can mass signoff using rebase:
 ```
 git rebase --signoff origin/develop
 ```
+
+Merge Strategy
+==============
+
+The preferred method for merging pull requests is squash merging to keep the
+commit history trim, but it is up to the discretion of the team member merging
+the change. When stacking pull requests, you may wish to do the following:
+
+1. Branch from develop to your branch (branch1), push commits onto it and open a pull request
+2. Branch from your base branch (branch1) to your work branch (branch2), push commits and open a pull request configuring the base to be branch1, saying in the description that it is based on your other PR.
+3. Merge the first PR using a merge commit otherwise your stacked PR will need a rebase. Github will automatically adjust the base branch of your other PR to be develop.
+
@@ -16,7 +16,7 @@ attached to ``window`` through which you can access the SDK. See below for how t
 include libolm to enable end-to-end-encryption.

 The browser bundle supports recent versions of browsers. Typically this is ES2015
-or `> 0.5%, last 2 versions, Firefox ESR, not dead` if using 
+or `> 0.5%, last 2 versions, Firefox ESR, not dead` if using
 [browserlists](https://github.com/browserslist/browserslist).

 Please check [the working browser example](examples/browser) for more information.
@@ -26,11 +26,11 @@ In Node.js

 Ensure you have the latest LTS version of Node.js installed.

-This SDK targets Node 10 for compatibility, which translates to ES6. If you're using
+This SDK targets Node 12 for compatibility, which translates to ES6. If you're using
 a bundler like webpack you'll likely have to transpile dependencies, including this
 SDK, to match your target browsers.

-Using `yarn` instead of `npm` is recommended. Please see the Yarn [install guide](https://classic.yarnpkg.com/en/docs/install) 
+Using `yarn` instead of `npm` is recommended. Please see the Yarn [install guide](https://classic.yarnpkg.com/en/docs/install)
 if you do not have it already.

 ``yarn add matrix-js-sdk``
@@ -307,7 +307,7 @@ The SDK supports end-to-end encryption via the Olm and Megolm protocols, using
 [libolm](https://gitlab.matrix.org/matrix-org/olm). It is left up to the
 application to make libolm available, via the ``Olm`` global.

-It is also necessary to call ``matrixClient.initCrypto()`` after creating a new
+It is also necessary to call ``await matrixClient.initCrypto()`` after creating a new
 ``MatrixClient`` (but **before** calling ``matrixClient.startClient()``) to
 initialise the crypto layer.

@@ -341,7 +341,7 @@ function printLine(event) {

    var maxNameWidth = 15;
    if (name.length > maxNameWidth) {
-        name = name.substr(0, maxNameWidth-1) + "\u2026";
+        name = name.slice(0, maxNameWidth-1) + "\u2026";
    }

    if (event.getType() === "m.room.message") {
@@ -398,7 +398,7 @@ function print(str, formatter) {

 function fixWidth(str, len) {
    if (str.length > len) {
-        return str.substr(0, len-2) + "\u2026";
+        return str.substring(0, len-2) + "\u2026";
    }
    else if (str.length < len) {
        return str + new Array(len - str.length).join(" ");
@@ -1,7 +1,10 @@
 {
  "name": "matrix-js-sdk",
-  "version": "17.0.0-rc.3",
+  "version": "17.2.0",
  "description": "Matrix Client-Server SDK for Javascript",
+  "engines": {
+    "node": ">=12.9.0"
+  },
  "scripts": {
    "prepublishOnly": "yarn build",
    "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
@@ -97,6 +100,7 @@
    "fake-indexeddb": "^3.1.2",
    "jest": "^26.6.3",
    "jest-localstorage-mock": "^2.4.6",
+    "jest-sonar-reporter": "^2.0.0",
    "jsdoc": "^3.6.6",
    "matrix-mock-request": "^1.2.3",
    "rimraf": "^3.0.2",
@@ -113,9 +117,14 @@
      "<rootDir>/src/**/*.{js,ts}"
    ],
    "coverageReporters": [
-      "text",
-      "json"
-    ]
+      "text-summary",
+      "lcov"
+    ],
+    "testResultsProcessor": "jest-sonar-reporter"
+  },
+  "jestSonar": {
+    "reportPath": "coverage",
+    "sonar56x": true
  },
  "typings": "./lib/index.d.ts"
 }
@@ -0,0 +1,21 @@
+sonar.projectKey=matrix-js-sdk
+sonar.organization=matrix-org
+
+# This is the name and version displayed in the SonarCloud UI.
+#sonar.projectName=matrix-js-sdk
+#sonar.projectVersion=1.0
+
+# Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows.
+#sonar.sources=.
+
+# Encoding of the source code. Default is default system encoding
+#sonar.sourceEncoding=UTF-8
+
+sonar.sources=src
+sonar.tests=spec
+sonar.exclusions=docs,examples,git-hooks
+
+sonar.typescript.tsconfigPath=./tsconfig.json
+sonar.javascript.lcov.reportPaths=coverage/lcov.info
+sonar.coverage.exclusions=spec/*.ts
+sonar.testExecutionReportPaths=coverage/test-report.xml
@@ -496,6 +496,7 @@ describe("MatrixClient event timelines", function() {
        });

        it("should handle thread replies with server support by fetching a contiguous thread timeline", async () => {
+            client.clientOpts.experimentalThreadSupport = true;
            Thread.setServerSideSupport(true);
            client.stopClient(); // we don't need the client to be syncing at this time
            const room = client.getRoom(roomId);
@@ -797,7 +797,7 @@ describe("MatrixClient", function() {
            ]);
        });

-        it("sends reply to thread responses to thread timeline only", () => {
+        it("sends reply to thread responses to main timeline only", () => {
            client.clientOpts = { experimentalThreadSupport: true };

            const threadRootEvent = buildEventPollStartThreadRoot();
@@ -814,12 +814,12 @@ describe("MatrixClient", function() {

            expect(timeline).toEqual([
                threadRootEvent,
+                replyToThreadResponse,
            ]);

            expect(threaded).toEqual([
                threadRootEvent,
                eventMessageInThread,
-                replyToThreadResponse,
            ]);
        });
    });
@@ -42,7 +42,6 @@ export const makeBeaconInfoEvent = (
    roomId: string,
    contentProps: Partial<InfoContentProps> = {},
    eventId?: string,
-    eventTypeSuffix?: string,
 ): MatrixEvent => {
    const {
        timeout, isLive, description, assetType,
@@ -51,12 +50,14 @@ export const makeBeaconInfoEvent = (
        ...contentProps,
    };
    const event = new MatrixEvent({
-        type: `${M_BEACON_INFO.name}.${sender}.${eventTypeSuffix || Date.now()}`,
+        type: M_BEACON_INFO.name,
        room_id: roomId,
        state_key: sender,
        content: makeBeaconInfoContent(timeout, isLive, description, assetType),
    });

+    event.event.origin_server_ts = Date.now();
+
    // live beacons use the beacon_info event id
    // set or default this
    event.replaceLocalEventId(eventId || `$${Math.random()}-${Math.random()}`);
@@ -16,7 +16,6 @@ limitations under the License.

 import { REFERENCE_RELATION } from "matrix-events-sdk";

-import { M_BEACON_INFO } from "../../src/@types/beacon";
 import { LocationAssetType, M_ASSET, M_LOCATION, M_TIMESTAMP } from "../../src/@types/location";
 import { makeBeaconContent, makeBeaconInfoContent } from "../../src/content-helpers";

@@ -36,11 +35,9 @@ describe('Beacon content helpers', () => {
                'nice beacon_info',
                LocationAssetType.Pin,
            )).toEqual({
-                [M_BEACON_INFO.name]: {
-                    description: 'nice beacon_info',
-                    timeout: 1234,
-                    live: true,
-                },
+                description: 'nice beacon_info',
+                timeout: 1234,
+                live: true,
                [M_TIMESTAMP.name]: mockDateNow,
                [M_ASSET.name]: {
                    type: LocationAssetType.Pin,
@@ -883,4 +883,138 @@ describe("Cross Signing", function() {
        expect(bobTrust3.isCrossSigningVerified()).toBeTruthy();
        expect(bobTrust3.isTofu()).toBeTruthy();
    });
+
+    it(
+        "should observe that our own device is cross-signed, even if this device doesn't trust the key",
+        async function() {
+            const { client: alice } = await makeTestClient(
+                { userId: "@alice:example.com", deviceId: "Osborne2" },
+            );
+            alice.uploadDeviceSigningKeys = async () => {};
+            alice.uploadKeySignatures = async () => {};
+
+            // Generate Alice's SSK etc
+            const aliceMasterSigning = new global.Olm.PkSigning();
+            const aliceMasterPrivkey = aliceMasterSigning.generate_seed();
+            const aliceMasterPubkey = aliceMasterSigning.init_with_seed(aliceMasterPrivkey);
+            const aliceSigning = new global.Olm.PkSigning();
+            const alicePrivkey = aliceSigning.generate_seed();
+            const alicePubkey = aliceSigning.init_with_seed(alicePrivkey);
+            const aliceSSK = {
+                user_id: "@alice:example.com",
+                usage: ["self_signing"],
+                keys: {
+                    ["ed25519:" + alicePubkey]: alicePubkey,
+                },
+            };
+            const sskSig = aliceMasterSigning.sign(anotherjson.stringify(aliceSSK));
+            aliceSSK.signatures = {
+                "@alice:example.com": {
+                    ["ed25519:" + aliceMasterPubkey]: sskSig,
+                },
+            };
+
+            // Alice's device downloads the keys, but doesn't trust them yet
+            alice.crypto.deviceList.storeCrossSigningForUser("@alice:example.com", {
+                keys: {
+                    master: {
+                        user_id: "@alice:example.com",
+                        usage: ["master"],
+                        keys: {
+                            ["ed25519:" + aliceMasterPubkey]: aliceMasterPubkey,
+                        },
+                    },
+                    self_signing: aliceSSK,
+                },
+                firstUse: 1,
+                unsigned: {},
+            });
+
+            // Alice has a second device that's cross-signed
+            const aliceCrossSignedDevice = {
+                user_id: "@alice:example.com",
+                device_id: "Dynabook",
+                algorithms: ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
+                keys: {
+                    "curve25519:Dynabook": "somePubkey",
+                    "ed25519:Dynabook": "someOtherPubkey",
+                },
+            };
+            const sig = aliceSigning.sign(anotherjson.stringify(aliceCrossSignedDevice));
+            aliceCrossSignedDevice.signatures = {
+                "@alice:example.com": {
+                    ["ed25519:" + alicePubkey]: sig,
+                },
+            };
+            alice.crypto.deviceList.storeDevicesForUser("@alice:example.com", {
+                Dynabook: aliceCrossSignedDevice,
+            });
+
+            // We don't trust the cross-signing keys yet...
+            expect(alice.checkDeviceTrust(aliceCrossSignedDevice.device_id).isCrossSigningVerified()).toBeFalsy();
+            // ... but we do acknowledge that the device is signed by them
+            expect(alice.checkIfOwnDeviceCrossSigned(aliceCrossSignedDevice.device_id)).toBeTruthy();
+        },
+    );
+
+    it("should observe that our own device isn't cross-signed", async function() {
+        const { client: alice } = await makeTestClient(
+            { userId: "@alice:example.com", deviceId: "Osborne2" },
+        );
+        alice.uploadDeviceSigningKeys = async () => {};
+        alice.uploadKeySignatures = async () => {};
+
+        // Generate Alice's SSK etc
+        const aliceMasterSigning = new global.Olm.PkSigning();
+        const aliceMasterPrivkey = aliceMasterSigning.generate_seed();
+        const aliceMasterPubkey = aliceMasterSigning.init_with_seed(aliceMasterPrivkey);
+        const aliceSigning = new global.Olm.PkSigning();
+        const alicePrivkey = aliceSigning.generate_seed();
+        const alicePubkey = aliceSigning.init_with_seed(alicePrivkey);
+        const aliceSSK = {
+            user_id: "@alice:example.com",
+            usage: ["self_signing"],
+            keys: {
+                ["ed25519:" + alicePubkey]: alicePubkey,
+            },
+        };
+        const sskSig = aliceMasterSigning.sign(anotherjson.stringify(aliceSSK));
+        aliceSSK.signatures = {
+            "@alice:example.com": {
+                ["ed25519:" + aliceMasterPubkey]: sskSig,
+            },
+        };
+
+        // Alice's device downloads the keys
+        alice.crypto.deviceList.storeCrossSigningForUser("@alice:example.com", {
+            keys: {
+                master: {
+                    user_id: "@alice:example.com",
+                    usage: ["master"],
+                    keys: {
+                        ["ed25519:" + aliceMasterPubkey]: aliceMasterPubkey,
+                    },
+                },
+                self_signing: aliceSSK,
+            },
+            firstUse: 1,
+            unsigned: {},
+        });
+
+        // Alice has a second device that's also not cross-signed
+        const aliceNotCrossSignedDevice = {
+            user_id: "@alice:example.com",
+            device_id: "Dynabook",
+            algorithms: ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
+            keys: {
+                "curve25519:Dynabook": "somePubkey",
+                "ed25519:Dynabook": "someOtherPubkey",
+            },
+        };
+        alice.crypto.deviceList.storeDevicesForUser("@alice:example.com", {
+            Dynabook: aliceNotCrossSignedDevice,
+        });
+
+        expect(alice.checkIfOwnDeviceCrossSigned(aliceNotCrossSignedDevice.device_id)).toBeFalsy();
+    });
 });
@@ -33,6 +33,7 @@ import * as testUtils from "../test-utils/test-utils";
 import { makeBeaconInfoContent } from "../../src/content-helpers";
 import { M_BEACON_INFO } from "../../src/@types/beacon";
 import { Room } from "../../src";
+import { makeBeaconEvent } from "../test-utils/beacon";

 jest.useFakeTimers();

@@ -810,11 +811,12 @@ describe("MatrixClient", function() {
                    }
                },
            },
-            threads: {
-                get: jest.fn(),
-            },
+            getThread: jest.fn(),
            addPendingEvent: jest.fn(),
            updatePendingEvent: jest.fn(),
+            reEmitter: {
+                reEmit: jest.fn(),
+            },
        };

        beforeEach(() => {
@@ -999,10 +1001,10 @@ describe("MatrixClient", function() {
        });

        it("creates new beacon info", async () => {
-            await client.unstable_createLiveBeacon(roomId, content, '123');
+            await client.unstable_createLiveBeacon(roomId, content);

            // event type combined
-            const expectedEventType = `${M_BEACON_INFO.name}.${userId}.123`;
+            const expectedEventType = M_BEACON_INFO.name;
            const [callback, method, path, queryParams, requestContent] = client.http.authedRequest.mock.calls[0];
            expect(callback).toBeFalsy();
            expect(method).toBe('PUT');
@@ -1015,17 +1017,97 @@ describe("MatrixClient", function() {
        });

        it("updates beacon info with specific event type", async () => {
-            const eventType = `${M_BEACON_INFO.name}.${userId}.456`;
-
-            await client.unstable_setLiveBeacon(roomId, eventType, content);
+            await client.unstable_setLiveBeacon(roomId, content);

            // event type combined
            const [, , path, , requestContent] = client.http.authedRequest.mock.calls[0];
            expect(path).toEqual(
                `/rooms/${encodeURIComponent(roomId)}/state/` +
-                `${encodeURIComponent(eventType)}/${encodeURIComponent(userId)}`,
+                `${encodeURIComponent(M_BEACON_INFO.name)}/${encodeURIComponent(userId)}`,
            );
            expect(requestContent).toEqual(content);
        });
+
+        describe('processBeaconEvents()', () => {
+            it('does nothing when events is falsy', () => {
+                const room = new Room(roomId, client, userId);
+                const roomStateProcessSpy = jest.spyOn(room.currentState, 'processBeaconEvents');
+
+                client.processBeaconEvents(room, undefined);
+                expect(roomStateProcessSpy).not.toHaveBeenCalled();
+            });
+
+            it('does nothing when events is of length 0', () => {
+                const room = new Room(roomId, client, userId);
+                const roomStateProcessSpy = jest.spyOn(room.currentState, 'processBeaconEvents');
+
+                client.processBeaconEvents(room, []);
+                expect(roomStateProcessSpy).not.toHaveBeenCalled();
+            });
+
+            it('calls room states processBeaconEvents with events', () => {
+                const room = new Room(roomId, client, userId);
+                const roomStateProcessSpy = jest.spyOn(room.currentState, 'processBeaconEvents');
+
+                const messageEvent = testUtils.mkMessage({ room: roomId, user: userId, event: true });
+                const beaconEvent = makeBeaconEvent(userId);
+
+                client.processBeaconEvents(room, [messageEvent, beaconEvent]);
+                expect(roomStateProcessSpy).toHaveBeenCalledWith([messageEvent, beaconEvent], client);
+            });
+        });
+    });
+
+    describe("setPassword", () => {
+        const auth = { session: 'abcdef', type: 'foo' };
+        const newPassword = 'newpassword';
+        const callback = () => {};
+
+        const passwordTest = (expectedRequestContent: any, expectedCallback?: Function) => {
+            const [callback, method, path, queryParams, requestContent] = client.http.authedRequest.mock.calls[0];
+            if (expectedCallback) {
+                expect(callback).toBe(expectedCallback);
+            } else {
+                expect(callback).toBeFalsy();
+            }
+            expect(method).toBe('POST');
+            expect(path).toEqual('/account/password');
+            expect(queryParams).toBeFalsy();
+            expect(requestContent).toEqual(expectedRequestContent);
+        };
+
+        beforeEach(() => {
+            client.http.authedRequest.mockClear().mockResolvedValue({});
+        });
+
+        it("no logout_devices specified", async () => {
+            await client.setPassword(auth, newPassword);
+            passwordTest({ auth, new_password: newPassword });
+        });
+
+        it("no logout_devices specified + callback", async () => {
+            await client.setPassword(auth, newPassword, callback);
+            passwordTest({ auth, new_password: newPassword }, callback);
+        });
+
+        it("overload logoutDevices=true", async () => {
+            await client.setPassword(auth, newPassword, true);
+            passwordTest({ auth, new_password: newPassword, logout_devices: true });
+        });
+
+        it("overload logoutDevices=true + callback", async () => {
+            await client.setPassword(auth, newPassword, true, callback);
+            passwordTest({ auth, new_password: newPassword, logout_devices: true }, callback);
+        });
+
+        it("overload logoutDevices=false", async () => {
+            await client.setPassword(auth, newPassword, false);
+            passwordTest({ auth, new_password: newPassword, logout_devices: false });
+        });
+
+        it("overload logoutDevices=false + callback", async () => {
+            await client.setPassword(auth, newPassword, false, callback);
+            passwordTest({ auth, new_password: newPassword, logout_devices: false }, callback);
+        });
    });
 });
@@ -14,15 +14,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { EventType } from "../../../src";
-import { M_BEACON_INFO } from "../../../src/@types/beacon";
 import {
    isTimestampInDuration,
-    isBeaconInfoEventType,
    Beacon,
    BeaconEvent,
 } from "../../../src/models/beacon";
-import { makeBeaconInfoEvent } from "../../test-utils/beacon";
+import { makeBeaconEvent, makeBeaconInfoEvent } from "../../test-utils/beacon";

 jest.useFakeTimers();

@@ -57,27 +54,9 @@ describe('Beacon', () => {
        });
    });

-    describe('isBeaconInfoEventType', () => {
-        it.each([
-            EventType.CallAnswer,
-            `prefix.${M_BEACON_INFO.name}`,
-            `prefix.${M_BEACON_INFO.altName}`,
-        ])('returns false for %s', (type) => {
-            expect(isBeaconInfoEventType(type)).toBe(false);
-        });
-
-        it.each([
-            M_BEACON_INFO.name,
-            M_BEACON_INFO.altName,
-            `${M_BEACON_INFO.name}.@test:server.org.12345`,
-            `${M_BEACON_INFO.altName}.@test:server.org.12345`,
-        ])('returns true for %s', (type) => {
-            expect(isBeaconInfoEventType(type)).toBe(true);
-        });
-    });
-
    describe('Beacon', () => {
        const userId = '@user:server.org';
+        const userId2 = '@user2:server.org';
        const roomId = '$room:server.org';
        // 14.03.2022 16:15
        const now = 1647270879403;
@@ -88,6 +67,7 @@ describe('Beacon', () => {
        // without timeout of 3 hours
        let liveBeaconEvent;
        let notLiveBeaconEvent;
+        let user2BeaconEvent;

        const advanceDateAndTime = (ms: number) => {
            // bc liveness check uses Date.now we have to advance this mock
@@ -107,14 +87,21 @@ describe('Beacon', () => {
                    isLive: true,
                },
                '$live123',
-                '$live123',
            );
            notLiveBeaconEvent = makeBeaconInfoEvent(
                userId,
                roomId,
                { timeout: HOUR_MS * 3, isLive: false },
                '$dead123',
-                '$dead123',
+            );
+            user2BeaconEvent = makeBeaconInfoEvent(
+                userId2,
+                roomId,
+                {
+                    timeout: HOUR_MS * 3,
+                    isLive: true,
+                },
+                '$user2live123',
            );

            // back to now
@@ -133,7 +120,7 @@ describe('Beacon', () => {
            expect(beacon.isLive).toEqual(true);
            expect(beacon.beaconInfoOwner).toEqual(userId);
            expect(beacon.beaconInfoEventType).toEqual(liveBeaconEvent.getType());
-            expect(beacon.identifier).toEqual(liveBeaconEvent.getType());
+            expect(beacon.identifier).toEqual(`${roomId}_${userId}`);
            expect(beacon.beaconInfo).toBeTruthy();
        });

@@ -171,8 +158,27 @@ describe('Beacon', () => {

                expect(beacon.beaconInfoId).toEqual(liveBeaconEvent.getId());

-                expect(() => beacon.update(notLiveBeaconEvent)).toThrow();
-                expect(beacon.isLive).toEqual(true);
+                expect(() => beacon.update(user2BeaconEvent)).toThrow();
+                // didnt update
+                expect(beacon.identifier).toEqual(`${roomId}_${userId}`);
+            });
+
+            it('does not update with an older event', () => {
+                const beacon = new Beacon(liveBeaconEvent);
+                const emitSpy = jest.spyOn(beacon, 'emit').mockClear();
+                expect(beacon.beaconInfoId).toEqual(liveBeaconEvent.getId());
+
+                const oldUpdateEvent = makeBeaconInfoEvent(
+                    userId,
+                    roomId,
+                );
+                // less than the original event
+                oldUpdateEvent.event.origin_server_ts = liveBeaconEvent.event.origin_server_ts - 1000;
+
+                beacon.update(oldUpdateEvent);
+                // didnt update
+                expect(emitSpy).not.toHaveBeenCalled();
+                expect(beacon.beaconInfoId).toEqual(liveBeaconEvent.getId());
            });

            it('updates event', () => {
@@ -182,7 +188,7 @@ describe('Beacon', () => {
                expect(beacon.isLive).toEqual(true);

                const updatedBeaconEvent = makeBeaconInfoEvent(
-                    userId, roomId, { timeout: HOUR_MS * 3, isLive: false }, '$live123', '$live123');
+                    userId, roomId, { timeout: HOUR_MS * 3, isLive: false }, '$live123');

                beacon.update(updatedBeaconEvent);
                expect(beacon.isLive).toEqual(false);
@@ -200,7 +206,6 @@ describe('Beacon', () => {
                    roomId,
                    { timeout: HOUR_MS * 3, isLive: false },
                    beacon.beaconInfoId,
-                    '$live123',
                );

                beacon.update(updatedBeaconEvent);
@@ -277,5 +282,93 @@ describe('Beacon', () => {
                expect(emitSpy).toHaveBeenCalledTimes(1);
            });
        });
+
+        describe('addLocations', () => {
+            it('ignores locations when beacon is not live', () => {
+                const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: false }));
+                const emitSpy = jest.spyOn(beacon, 'emit');
+
+                beacon.addLocations([
+                    makeBeaconEvent(userId, { beaconInfoId: beacon.beaconInfoId, timestamp: now + 1 }),
+                ]);
+
+                expect(beacon.latestLocationState).toBeFalsy();
+                expect(emitSpy).not.toHaveBeenCalled();
+            });
+
+            it('ignores locations outside the beacon live duration', () => {
+                const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
+                const emitSpy = jest.spyOn(beacon, 'emit');
+
+                beacon.addLocations([
+                    // beacon has now + 60000 live period
+                    makeBeaconEvent(userId, { beaconInfoId: beacon.beaconInfoId, timestamp: now + 100000 }),
+                ]);
+
+                expect(beacon.latestLocationState).toBeFalsy();
+                expect(emitSpy).not.toHaveBeenCalled();
+            });
+
+            it('sets latest location state to most recent location', () => {
+                const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
+                const emitSpy = jest.spyOn(beacon, 'emit');
+
+                const locations = [
+                    // older
+                    makeBeaconEvent(
+                        userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:foo', timestamp: now + 1 },
+                    ),
+                    // newer
+                    makeBeaconEvent(
+                        userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:bar', timestamp: now + 10000 },
+                    ),
+                    // not valid
+                    makeBeaconEvent(
+                        userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:baz', timestamp: now - 5 },
+                    ),
+                ];
+
+                beacon.addLocations(locations);
+
+                const expectedLatestLocation = {
+                    description: undefined,
+                    timestamp: now + 10000,
+                    uri: 'geo:bar',
+                };
+
+                // the newest valid location
+                expect(beacon.latestLocationState).toEqual(expectedLatestLocation);
+                expect(emitSpy).toHaveBeenCalledWith(BeaconEvent.LocationUpdate, expectedLatestLocation);
+            });
+
+            it('ignores locations that are less recent that the current latest location', () => {
+                const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
+
+                const olderLocation = makeBeaconEvent(
+                    userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:foo', timestamp: now + 1 },
+                );
+                const newerLocation = makeBeaconEvent(
+                    userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:bar', timestamp: now + 10000 },
+                );
+
+                beacon.addLocations([newerLocation]);
+                // latest location set to newerLocation
+                expect(beacon.latestLocationState).toEqual(expect.objectContaining({
+                    uri: 'geo:bar',
+                }));
+
+                const emitSpy = jest.spyOn(beacon, 'emit').mockClear();
+
+                // add older location
+                beacon.addLocations([olderLocation]);
+
+                // no change
+                expect(beacon.latestLocationState).toEqual(expect.objectContaining({
+                    uri: 'geo:bar',
+                }));
+                // no emit
+                expect(emitSpy).not.toHaveBeenCalled();
+            });
+        });
    });
 });
@@ -130,4 +130,49 @@ describe("Relations", function() {
            await relationsCreated;
        }
    });
+
+    it("should ignore m.replace for state events", async () => {
+        const userId = "@bob:example.com";
+        const room = new Room("room123", null, userId);
+        const relations = new Relations("m.replace", "m.room.topic", room);
+
+        // Create an instance of a state event with rel_type m.replace
+        const originalTopic = new MatrixEvent({
+            "sender": userId,
+            "type": "m.room.topic",
+            "event_id": "$orig",
+            "room_id": room.roomId,
+            "content": {
+                "topic": "orig",
+            },
+            "state_key": "",
+        });
+        const badlyEditedTopic = new MatrixEvent({
+            "sender": userId,
+            "type": "m.room.topic",
+            "event_id": "$orig",
+            "room_id": room.roomId,
+            "content": {
+                "topic": "topic",
+                "m.new_content": {
+                    "topic": "edit",
+                },
+                "m.relates_to": {
+                    "event_id": "$orig",
+                    "rel_type": "m.replace",
+                },
+            },
+            "state_key": "",
+        });
+
+        await relations.setTargetEvent(originalTopic);
+        expect(originalTopic.replacingEvent()).toBe(null);
+        expect(originalTopic.getContent().topic).toBe("orig");
+
+        await relations.addEvent(badlyEditedTopic);
+        expect(originalTopic.replacingEvent()).toBe(null);
+        expect(originalTopic.getContent().topic).toBe("orig");
+        expect(badlyEditedTopic.replacingEvent()).toBe(null);
+        expect(badlyEditedTopic.getContent().topic).toBe("topic");
+    });
 });
@@ -1,8 +1,14 @@
 import * as utils from "../test-utils/test-utils";
-import { makeBeaconInfoEvent } from "../test-utils/beacon";
+import { makeBeaconEvent, makeBeaconInfoEvent } from "../test-utils/beacon";
 import { filterEmitCallsByEventType } from "../test-utils/emitter";
 import { RoomState, RoomStateEvent } from "../../src/models/room-state";
-import { BeaconEvent } from "../../src/models/beacon";
+import { BeaconEvent, getBeaconInfoIdentifier } from "../../src/models/beacon";
+import { EventType, RelationType } from "../../src/@types/event";
+import {
+    MatrixEvent,
+    MatrixEventEvent,
+} from "../../src/models/event";
+import { M_BEACON } from "../../src/@types/beacon";

 describe("RoomState", function() {
    const roomId = "!foo:bar";
@@ -260,7 +266,7 @@ describe("RoomState", function() {
                state.setStateEvents([beaconEvent]);

                expect(state.beacons.size).toEqual(1);
-                const beaconInstance = state.beacons.get(beaconEvent.getType());
+                const beaconInstance = state.beacons.get(`${roomId}_${userA}`);
                expect(beaconInstance).toBeTruthy();
                expect(emitSpy).toHaveBeenCalledWith(BeaconEvent.New, beaconEvent, beaconInstance);
            });
@@ -275,49 +281,49 @@ describe("RoomState", function() {

                // no beacon added
                expect(state.beacons.size).toEqual(0);
-                expect(state.beacons.get(redactedBeaconEvent.getType)).toBeFalsy();
+                expect(state.beacons.get(getBeaconInfoIdentifier(redactedBeaconEvent))).toBeFalsy();
                // no new beacon emit
                expect(filterEmitCallsByEventType(BeaconEvent.New, emitSpy).length).toBeFalsy();
            });

            it('updates existing beacon info events in state', () => {
                const beaconId = '$beacon1';
-                const beaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, beaconId, beaconId);
-                const updatedBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: false }, beaconId, beaconId);
+                const beaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, beaconId);
+                const updatedBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: false }, beaconId);

                state.setStateEvents([beaconEvent]);
-                const beaconInstance = state.beacons.get(beaconEvent.getType());
+                const beaconInstance = state.beacons.get(getBeaconInfoIdentifier(beaconEvent));
                expect(beaconInstance.isLive).toEqual(true);

                state.setStateEvents([updatedBeaconEvent]);

                // same Beacon
-                expect(state.beacons.get(beaconEvent.getType())).toBe(beaconInstance);
+                expect(state.beacons.get(getBeaconInfoIdentifier(beaconEvent))).toBe(beaconInstance);
                // updated liveness
-                expect(state.beacons.get(beaconEvent.getType()).isLive).toEqual(false);
+                expect(state.beacons.get(getBeaconInfoIdentifier(beaconEvent)).isLive).toEqual(false);
            });

            it('destroys and removes redacted beacon events', () => {
                const beaconId = '$beacon1';
-                const beaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, beaconId, beaconId);
-                const redactedBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, beaconId, beaconId);
-                const redactionEvent = { event: { type: 'm.room.redaction' } };
+                const beaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, beaconId);
+                const redactedBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, beaconId);
+                const redactionEvent = { event: { type: 'm.room.redaction', redacts: beaconEvent.getId() } };
                redactedBeaconEvent.makeRedacted(redactionEvent);

                state.setStateEvents([beaconEvent]);
-                const beaconInstance = state.beacons.get(beaconEvent.getType());
+                const beaconInstance = state.beacons.get(getBeaconInfoIdentifier(beaconEvent));
                const destroySpy = jest.spyOn(beaconInstance, 'destroy');
                expect(beaconInstance.isLive).toEqual(true);

                state.setStateEvents([redactedBeaconEvent]);

                expect(destroySpy).toHaveBeenCalled();
-                expect(state.beacons.get(beaconEvent.getType())).toBe(undefined);
+                expect(state.beacons.get(getBeaconInfoIdentifier(beaconEvent))).toBe(undefined);
            });

            it('updates live beacon ids once after setting state events', () => {
-                const liveBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, '$beacon1', '$beacon1');
-                const deadBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: false }, '$beacon2', '$beacon2');
+                const liveBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, '$beacon1');
+                const deadBeaconEvent = makeBeaconInfoEvent(userB, roomId, { isLive: false }, '$beacon2');

                const emitSpy = jest.spyOn(state, 'emit');

@@ -334,7 +340,7 @@ describe("RoomState", function() {
                state.setStateEvents([updatedLiveBeaconEvent]);

                expect(state.hasLiveBeacons).toBe(false);
-                expect(filterEmitCallsByEventType(RoomStateEvent.BeaconLiveness, emitSpy).length).toBe(2);
+                expect(filterEmitCallsByEventType(RoomStateEvent.BeaconLiveness, emitSpy).length).toBe(3);
                expect(emitSpy).toHaveBeenCalledWith(RoomStateEvent.BeaconLiveness, state, false);
            });
        });
@@ -712,4 +718,243 @@ describe("RoomState", function() {
            expect(state.maySendEvent('m.room.other_thing', userB)).toEqual(false);
        });
    });
+
+    describe('processBeaconEvents', () => {
+        const beacon1 = makeBeaconInfoEvent(userA, roomId, {}, '$beacon1', '$beacon1');
+        const beacon2 = makeBeaconInfoEvent(userB, roomId, {}, '$beacon2', '$beacon2');
+
+        const mockClient = { decryptEventIfNeeded: jest.fn() };
+
+        beforeEach(() => {
+            mockClient.decryptEventIfNeeded.mockClear();
+        });
+
+        it('does nothing when state has no beacons', () => {
+            const emitSpy = jest.spyOn(state, 'emit');
+            state.processBeaconEvents([makeBeaconEvent(userA, { beaconInfoId: '$beacon1' })], mockClient);
+            expect(emitSpy).not.toHaveBeenCalled();
+            expect(mockClient.decryptEventIfNeeded).not.toHaveBeenCalled();
+        });
+
+        it('does nothing when there are no events', () => {
+            state.setStateEvents([beacon1, beacon2]);
+            const emitSpy = jest.spyOn(state, 'emit').mockClear();
+            state.processBeaconEvents([], mockClient);
+            expect(emitSpy).not.toHaveBeenCalled();
+            expect(mockClient.decryptEventIfNeeded).not.toHaveBeenCalled();
+        });
+
+        describe('without encryption', () => {
+            it('discards events for beacons that are not in state', () => {
+                const location = makeBeaconEvent(userA, {
+                    beaconInfoId: 'some-other-beacon',
+                });
+                const otherRelatedEvent = new MatrixEvent({
+                    sender: userA,
+                    type: EventType.RoomMessage,
+                    content: {
+                        ['m.relates_to']: {
+                            event_id: 'whatever',
+                        },
+                    },
+                });
+                state.setStateEvents([beacon1, beacon2]);
+                const emitSpy = jest.spyOn(state, 'emit').mockClear();
+                state.processBeaconEvents([location, otherRelatedEvent], mockClient);
+                expect(emitSpy).not.toHaveBeenCalled();
+            });
+
+            it('discards events that are not beacon type', () => {
+                // related to beacon1
+                const otherRelatedEvent = new MatrixEvent({
+                    sender: userA,
+                    type: EventType.RoomMessage,
+                    content: {
+                        ['m.relates_to']: {
+                            rel_type: RelationType.Reference,
+                            event_id: beacon1.getId(),
+                        },
+                    },
+                });
+                state.setStateEvents([beacon1, beacon2]);
+                const emitSpy = jest.spyOn(state, 'emit').mockClear();
+                state.processBeaconEvents([otherRelatedEvent], mockClient);
+                expect(emitSpy).not.toHaveBeenCalled();
+            });
+
+            it('adds locations to beacons', () => {
+                const location1 = makeBeaconEvent(userA, {
+                    beaconInfoId: '$beacon1', timestamp: Date.now() + 1,
+                });
+                const location2 = makeBeaconEvent(userA, {
+                    beaconInfoId: '$beacon1', timestamp: Date.now() + 2,
+                });
+                const location3 = makeBeaconEvent(userB, {
+                    beaconInfoId: 'some-other-beacon',
+                });
+
+                state.setStateEvents([beacon1, beacon2], mockClient);
+
+                expect(state.beacons.size).toEqual(2);
+
+                const beaconInstance = state.beacons.get(getBeaconInfoIdentifier(beacon1));
+                const addLocationsSpy = jest.spyOn(beaconInstance, 'addLocations');
+
+                state.processBeaconEvents([location1, location2, location3], mockClient);
+
+                expect(addLocationsSpy).toHaveBeenCalledTimes(2);
+                // only called with locations for beacon1
+                expect(addLocationsSpy).toHaveBeenCalledWith([location1]);
+                expect(addLocationsSpy).toHaveBeenCalledWith([location2]);
+            });
+        });
+
+        describe('with encryption', () => {
+            const beacon1RelationContent = { ['m.relates_to']: {
+                rel_type: RelationType.Reference,
+                event_id: beacon1.getId(),
+            } };
+            const relatedEncryptedEvent = new MatrixEvent({
+                sender: userA,
+                type: EventType.RoomMessageEncrypted,
+                content: beacon1RelationContent,
+            });
+            const decryptingRelatedEvent = new MatrixEvent({
+                sender: userA,
+                type: EventType.RoomMessageEncrypted,
+                content: beacon1RelationContent,
+            });
+            jest.spyOn(decryptingRelatedEvent, 'isBeingDecrypted').mockReturnValue(true);
+
+            const failedDecryptionRelatedEvent = new MatrixEvent({
+                sender: userA,
+                type: EventType.RoomMessageEncrypted,
+                content: beacon1RelationContent,
+            });
+            jest.spyOn(failedDecryptionRelatedEvent, 'isDecryptionFailure').mockReturnValue(true);
+
+            it('discards events without relations', () => {
+                const unrelatedEvent = new MatrixEvent({
+                    sender: userA,
+                    type: EventType.RoomMessageEncrypted,
+                });
+                state.setStateEvents([beacon1, beacon2]);
+                const emitSpy = jest.spyOn(state, 'emit').mockClear();
+                state.processBeaconEvents([unrelatedEvent], mockClient);
+                expect(emitSpy).not.toHaveBeenCalled();
+                // discard unrelated events early
+                expect(mockClient.decryptEventIfNeeded).not.toHaveBeenCalled();
+            });
+
+            it('discards events for beacons that are not in state', () => {
+                const location = makeBeaconEvent(userA, {
+                    beaconInfoId: 'some-other-beacon',
+                });
+                const otherRelatedEvent = new MatrixEvent({
+                    sender: userA,
+                    type: EventType.RoomMessageEncrypted,
+                    content: {
+                        ['m.relates_to']: {
+                            rel_type: RelationType.Reference,
+                            event_id: 'whatever',
+                        },
+                    },
+                });
+                state.setStateEvents([beacon1, beacon2]);
+
+                const beacon = state.beacons.get(getBeaconInfoIdentifier(beacon1));
+                const addLocationsSpy = jest.spyOn(beacon, 'addLocations').mockClear();
+                state.processBeaconEvents([location, otherRelatedEvent], mockClient);
+                expect(addLocationsSpy).not.toHaveBeenCalled();
+                // discard unrelated events early
+                expect(mockClient.decryptEventIfNeeded).not.toHaveBeenCalled();
+            });
+
+            it('decrypts related events if needed', () => {
+                const location = makeBeaconEvent(userA, {
+                    beaconInfoId: beacon1.getId(),
+                });
+                state.setStateEvents([beacon1, beacon2]);
+                state.processBeaconEvents([location, relatedEncryptedEvent], mockClient);
+                // discard unrelated events early
+                expect(mockClient.decryptEventIfNeeded).toHaveBeenCalledTimes(2);
+            });
+
+            it('listens for decryption on events that are being decrypted', () => {
+                const decryptingRelatedEvent = new MatrixEvent({
+                    sender: userA,
+                    type: EventType.RoomMessageEncrypted,
+                    content: beacon1RelationContent,
+                });
+                jest.spyOn(decryptingRelatedEvent, 'isBeingDecrypted').mockReturnValue(true);
+                // spy on event.once
+                const eventOnceSpy = jest.spyOn(decryptingRelatedEvent, 'once');
+
+                state.setStateEvents([beacon1, beacon2]);
+                state.processBeaconEvents([decryptingRelatedEvent], mockClient);
+
+                // listener was added
+                expect(eventOnceSpy).toHaveBeenCalled();
+            });
+
+            it('listens for decryption on events that have decryption failure', () => {
+                const failedDecryptionRelatedEvent = new MatrixEvent({
+                    sender: userA,
+                    type: EventType.RoomMessageEncrypted,
+                    content: beacon1RelationContent,
+                });
+                jest.spyOn(failedDecryptionRelatedEvent, 'isDecryptionFailure').mockReturnValue(true);
+                // spy on event.once
+                const eventOnceSpy = jest.spyOn(decryptingRelatedEvent, 'once');
+
+                state.setStateEvents([beacon1, beacon2]);
+                state.processBeaconEvents([decryptingRelatedEvent], mockClient);
+
+                // listener was added
+                expect(eventOnceSpy).toHaveBeenCalled();
+            });
+
+            it('discard events that are not m.beacon type after decryption', () => {
+                const decryptingRelatedEvent = new MatrixEvent({
+                    sender: userA,
+                    type: EventType.RoomMessageEncrypted,
+                    content: beacon1RelationContent,
+                });
+                jest.spyOn(decryptingRelatedEvent, 'isBeingDecrypted').mockReturnValue(true);
+                state.setStateEvents([beacon1, beacon2]);
+                const beacon = state.beacons.get(getBeaconInfoIdentifier(beacon1));
+                const addLocationsSpy = jest.spyOn(beacon, 'addLocations').mockClear();
+                state.processBeaconEvents([decryptingRelatedEvent], mockClient);
+
+                // this event is a message after decryption
+                decryptingRelatedEvent.type = EventType.RoomMessage;
+                decryptingRelatedEvent.emit(MatrixEventEvent.Decrypted);
+
+                expect(addLocationsSpy).not.toHaveBeenCalled();
+            });
+
+            it('adds locations to beacons after decryption', () => {
+                const decryptingRelatedEvent = new MatrixEvent({
+                    sender: userA,
+                    type: EventType.RoomMessageEncrypted,
+                    content: beacon1RelationContent,
+                });
+                const locationEvent = makeBeaconEvent(userA, {
+                    beaconInfoId: '$beacon1', timestamp: Date.now() + 1,
+                });
+                jest.spyOn(decryptingRelatedEvent, 'isBeingDecrypted').mockReturnValue(true);
+                state.setStateEvents([beacon1, beacon2]);
+                const beacon = state.beacons.get(getBeaconInfoIdentifier(beacon1));
+                const addLocationsSpy = jest.spyOn(beacon, 'addLocations').mockClear();
+                state.processBeaconEvents([decryptingRelatedEvent], mockClient);
+
+                // update type after '''decryption'''
+                decryptingRelatedEvent.event.type = M_BEACON.name;
+                decryptingRelatedEvent.event.content = locationEvent.content;
+                decryptingRelatedEvent.emit(MatrixEventEvent.Decrypted);
+
+                expect(addLocationsSpy).toHaveBeenCalledWith([decryptingRelatedEvent]);
+            });
+        });
+    });
 });
@@ -36,7 +36,7 @@ import { RoomState } from "../../src/models/room-state";
 import { UNSTABLE_ELEMENT_FUNCTIONAL_USERS } from "../../src/@types/event";
 import { TestClient } from "../TestClient";
 import { emitPromise } from "../test-utils/test-utils";
-import { ThreadEvent } from "../../src/models/thread";
+import { Thread, ThreadEvent } from "../../src/models/thread";

 describe("Room", function() {
    const roomId = "!foo:bar";
@@ -1471,16 +1471,13 @@ describe("Room", function() {
                isRoomEncrypted: function() {
                    return false;
                },
-                http: {
-                    serverResponse,
-                    authedRequest: function() {
-                        if (this.serverResponse instanceof Error) {
-                            return Promise.reject(this.serverResponse);
-                        } else {
-                            return Promise.resolve({ chunk: this.serverResponse });
-                        }
-                    },
-                },
+                members: jest.fn().mockImplementation(() => {
+                    if (serverResponse instanceof Error) {
+                        return Promise.reject(serverResponse);
+                    } else {
+                        return Promise.resolve({ chunk: serverResponse });
+                    }
+                }),
                store: {
                    storageResponse,
                    storedMembers: null,
@@ -1547,7 +1544,7 @@ describe("Room", function() {
            }
            expect(hasThrown).toEqual(true);

-            client.http.serverResponse = [memberEvent];
+            client.members.mockReturnValue({ chunk: [memberEvent] });
            await room.loadMembersIfNeeded();
            const memberA = room.getMember("@user_a:bar");
            expect(memberA.name).toEqual("User A");
@@ -1917,7 +1914,7 @@ describe("Room", function() {
                },
            });

-            room.createThread(undefined, [eventWithoutARootEvent]);
+            room.createThread("$000", undefined, [eventWithoutARootEvent]);

            const rootEvent = new MatrixEvent({
                event_id: "$666",
@@ -1935,7 +1932,7 @@ describe("Room", function() {
                },
            });

-            expect(() => room.createThread(rootEvent, [])).not.toThrow();
+            expect(() => room.createThread(rootEvent.getId(), rootEvent, [])).not.toThrow();
        });

        it("Edits update the lastReply event", async () => {
@@ -1962,14 +1959,16 @@ describe("Room", function() {
                },
            });

+            let prom = emitPromise(room, ThreadEvent.New);
            room.addLiveEvents([randomMessage, threadRoot, threadResponse]);
-            const thread = await emitPromise(room, ThreadEvent.New);
+            const thread = await prom;

            expect(thread.replyToEvent).toBe(threadResponse);
            expect(thread.replyToEvent.getContent().body).toBe(threadResponse.getContent().body);

+            prom = emitPromise(thread, ThreadEvent.Update);
            room.addLiveEvents([threadResponseEdit]);
-            await emitPromise(thread, ThreadEvent.Update);
+            await prom;
            expect(thread.replyToEvent.getContent().body).toBe(threadResponseEdit.getContent()["m.new_content"].body);
        });

@@ -1996,15 +1995,17 @@ describe("Room", function() {
                },
            });

+            let prom = emitPromise(room, ThreadEvent.New);
            room.addLiveEvents([threadRoot, threadResponse1, threadResponse2]);
-            const thread = await emitPromise(room, ThreadEvent.New);
+            const thread = await prom;

            expect(thread).toHaveLength(2);
            expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());

+            prom = emitPromise(thread, ThreadEvent.Update);
            const threadResponse1Redaction = mkRedaction(threadResponse1);
            room.addLiveEvents([threadResponse1Redaction]);
-            await emitPromise(thread, ThreadEvent.Update);
+            await prom;
            expect(thread).toHaveLength(1);
            expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());
        });
@@ -2033,19 +2034,59 @@ describe("Room", function() {
                },
            });

+            let prom = emitPromise(room, ThreadEvent.New);
            room.addLiveEvents([threadRoot, threadResponse1, threadResponse2, threadResponse2Reaction]);
-            const thread = await emitPromise(room, ThreadEvent.New);
+            const thread = await prom;

            expect(thread).toHaveLength(2);
            expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());

+            prom = emitPromise(thread, ThreadEvent.Update);
            const threadResponse2ReactionRedaction = mkRedaction(threadResponse2Reaction);
            room.addLiveEvents([threadResponse2ReactionRedaction]);
-            await emitPromise(thread, ThreadEvent.Update);
+            await prom;
            expect(thread).toHaveLength(2);
            expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());
        });

+        it("should not decrement the length when the thread root is redacted", async () => {
+            room.client.supportsExperimentalThreads = () => true;
+
+            const threadRoot = mkMessage();
+            const threadResponse1 = mkThreadResponse(threadRoot);
+            threadResponse1.localTimestamp += 1000;
+            const threadResponse2 = mkThreadResponse(threadRoot);
+            threadResponse2.localTimestamp += 2000;
+            const threadResponse2Reaction = mkReaction(threadResponse2);
+
+            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
+                ...threadRoot.event,
+                unsigned: {
+                    "age": 123,
+                    "m.relations": {
+                        "m.thread": {
+                            latest_event: threadResponse2.event,
+                            count: 2,
+                            current_user_participated: true,
+                        },
+                    },
+                },
+            });
+
+            let prom = emitPromise(room, ThreadEvent.New);
+            room.addLiveEvents([threadRoot, threadResponse1, threadResponse2, threadResponse2Reaction]);
+            const thread = await prom;
+
+            expect(thread).toHaveLength(2);
+            expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());
+
+            prom = emitPromise(room, ThreadEvent.Update);
+            const threadRootRedaction = mkRedaction(threadRoot);
+            room.addLiveEvents([threadRootRedaction]);
+            await prom;
+            expect(thread).toHaveLength(2);
+        });
+
        it("Redacting the lastEvent finds a new lastEvent", async () => {
            room.client.supportsExperimentalThreads = () => true;

@@ -2069,21 +2110,24 @@ describe("Room", function() {
                },
            });

+            let prom = emitPromise(room, ThreadEvent.New);
            room.addLiveEvents([threadRoot, threadResponse1, threadResponse2]);
-            const thread = await emitPromise(room, ThreadEvent.New);
+            const thread = await prom;

            expect(thread).toHaveLength(2);
            expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());

+            prom = emitPromise(room, ThreadEvent.Update);
            const threadResponse2Redaction = mkRedaction(threadResponse2);
            room.addLiveEvents([threadResponse2Redaction]);
-            await emitPromise(thread, ThreadEvent.Update);
+            await prom;
            expect(thread).toHaveLength(1);
            expect(thread.replyToEvent.getId()).toBe(threadResponse1.getId());

+            prom = emitPromise(room, ThreadEvent.Update);
            const threadResponse1Redaction = mkRedaction(threadResponse1);
            room.addLiveEvents([threadResponse1Redaction]);
-            await emitPromise(thread, ThreadEvent.Update);
+            await prom;
            expect(thread).toHaveLength(0);
            expect(thread.replyToEvent.getId()).toBe(threadRoot.getId());
        });
@@ -2154,36 +2198,32 @@ describe("Room", function() {
            expect(room.eventShouldLiveIn(threadReaction2Redaction, events, roots).threadId).toBe(threadRoot.getId());
        });

-        it("reply to thread response and its relations&redactions should be only in thread timeline", () => {
+        it("reply to thread response and its relations&redactions should be only in main timeline", () => {
            const threadRoot = mkMessage();
            const threadResponse1 = mkThreadResponse(threadRoot);
            const reply1 = mkReply(threadResponse1);
-            const threadReaction1 = mkReaction(reply1);
-            const threadReaction2 = mkReaction(reply1);
-            const threadReaction2Redaction = mkRedaction(reply1);
+            const reaction1 = mkReaction(reply1);
+            const reaction2 = mkReaction(reply1);
+            const reaction2Redaction = mkRedaction(reply1);

            const roots = new Set([threadRoot.getId()]);
            const events = [
                threadRoot,
                threadResponse1,
                reply1,
-                threadReaction1,
-                threadReaction2,
-                threadReaction2Redaction,
+                reaction1,
+                reaction2,
+                reaction2Redaction,
            ];

-            expect(room.eventShouldLiveIn(reply1, events, roots).shouldLiveInRoom).toBeFalsy();
-            expect(room.eventShouldLiveIn(reply1, events, roots).shouldLiveInThread).toBeTruthy();
-            expect(room.eventShouldLiveIn(reply1, events, roots).threadId).toBe(threadRoot.getId());
-            expect(room.eventShouldLiveIn(threadReaction1, events, roots).shouldLiveInRoom).toBeFalsy();
-            expect(room.eventShouldLiveIn(threadReaction1, events, roots).shouldLiveInThread).toBeTruthy();
-            expect(room.eventShouldLiveIn(threadReaction1, events, roots).threadId).toBe(threadRoot.getId());
-            expect(room.eventShouldLiveIn(threadReaction2, events, roots).shouldLiveInRoom).toBeFalsy();
-            expect(room.eventShouldLiveIn(threadReaction2, events, roots).shouldLiveInThread).toBeTruthy();
-            expect(room.eventShouldLiveIn(threadReaction2, events, roots).threadId).toBe(threadRoot.getId());
-            expect(room.eventShouldLiveIn(threadReaction2Redaction, events, roots).shouldLiveInRoom).toBeFalsy();
-            expect(room.eventShouldLiveIn(threadReaction2Redaction, events, roots).shouldLiveInThread).toBeTruthy();
-            expect(room.eventShouldLiveIn(threadReaction2Redaction, events, roots).threadId).toBe(threadRoot.getId());
+            expect(room.eventShouldLiveIn(reply1, events, roots).shouldLiveInRoom).toBeTruthy();
+            expect(room.eventShouldLiveIn(reply1, events, roots).shouldLiveInThread).toBeFalsy();
+            expect(room.eventShouldLiveIn(reaction1, events, roots).shouldLiveInRoom).toBeTruthy();
+            expect(room.eventShouldLiveIn(reaction1, events, roots).shouldLiveInThread).toBeFalsy();
+            expect(room.eventShouldLiveIn(reaction2, events, roots).shouldLiveInRoom).toBeTruthy();
+            expect(room.eventShouldLiveIn(reaction2, events, roots).shouldLiveInThread).toBeFalsy();
+            expect(room.eventShouldLiveIn(reaction2Redaction, events, roots).shouldLiveInRoom).toBeTruthy();
+            expect(room.eventShouldLiveIn(reaction2Redaction, events, roots).shouldLiveInThread).toBeFalsy();
        });

        it("reply to reply to thread root should only be in the main timeline", () => {
@@ -2205,5 +2245,45 @@ describe("Room", function() {
            expect(room.eventShouldLiveIn(reply2, events, roots).shouldLiveInRoom).toBeTruthy();
            expect(room.eventShouldLiveIn(reply2, events, roots).shouldLiveInThread).toBeFalsy();
        });
+
+        it("should aggregate relations in thread event timeline set", () => {
+            Thread.setServerSideSupport(true, true);
+            const threadRoot = mkMessage();
+            const rootReaction = mkReaction(threadRoot);
+            const threadResponse = mkThreadResponse(threadRoot);
+            const threadReaction = mkReaction(threadResponse);
+
+            const events = [
+                threadRoot,
+                rootReaction,
+                threadResponse,
+                threadReaction,
+            ];
+
+            room.addLiveEvents(events);
+
+            const thread = threadRoot.getThread();
+            expect(thread.rootEvent).toBe(threadRoot);
+
+            const rootRelations = thread.timelineSet.getRelationsForEvent(
+                threadRoot.getId(),
+                RelationType.Annotation,
+                EventType.Reaction,
+            ).getSortedAnnotationsByKey();
+            expect(rootRelations).toHaveLength(1);
+            expect(rootRelations[0][0]).toEqual(rootReaction.getRelation().key);
+            expect(rootRelations[0][1].size).toEqual(1);
+            expect(rootRelations[0][1].has(rootReaction)).toBeTruthy();
+
+            const responseRelations = thread.timelineSet.getRelationsForEvent(
+                threadResponse.getId(),
+                RelationType.Annotation,
+                EventType.Reaction,
+            ).getSortedAnnotationsByKey();
+            expect(responseRelations).toHaveLength(1);
+            expect(responseRelations[0][0]).toEqual(threadReaction.getRelation().key);
+            expect(responseRelations[0][1].size).toEqual(1);
+            expect(responseRelations[0][1].has(threadReaction)).toBeTruthy();
+        });
    });
 });
@@ -10,8 +10,11 @@ import {
    prevString,
    simpleRetryOperation,
    stringToBase,
+    sortEventsByLatestContentTimestamp,
 } from "../../src/utils";
 import { logger } from "../../src/logger";
+import { mkMessage } from "../test-utils/test-utils";
+import { makeBeaconEvent } from "../test-utils/beacon";

 // TODO: Fix types throughout

@@ -506,4 +509,30 @@ describe("utils", function() {
            });
        });
    });
+
+    describe('sortEventsByLatestContentTimestamp', () => {
+        const roomId = '!room:server';
+        const userId = '@user:server';
+        const eventWithoutContentTimestamp = mkMessage({ room: roomId, user: userId, event: true });
+        // m.beacon events have timestamp in content
+        const beaconEvent1 = makeBeaconEvent(userId, { timestamp: 1648804528557 });
+        const beaconEvent2 = makeBeaconEvent(userId, { timestamp: 1648804528558 });
+        const beaconEvent3 = makeBeaconEvent(userId, { timestamp: 1648804528000 });
+        const beaconEvent4 = makeBeaconEvent(userId, { timestamp: 0 });
+
+        it('sorts events with timestamps as later than events without', () => {
+            expect(
+                [beaconEvent4, eventWithoutContentTimestamp, beaconEvent1]
+                    .sort(utils.sortEventsByLatestContentTimestamp),
+            ).toEqual([
+                beaconEvent1, beaconEvent4, eventWithoutContentTimestamp,
+            ]);
+        });
+
+        it('sorts by content timestamps correctly', () => {
+            expect(
+                [beaconEvent1, beaconEvent2, beaconEvent3].sort(sortEventsByLatestContentTimestamp),
+            ).toEqual([beaconEvent2, beaconEvent1, beaconEvent3]);
+        });
+    });
 });
@@ -14,14 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { EitherAnd, RELATES_TO_RELATIONSHIP, REFERENCE_RELATION } from "matrix-events-sdk";
+import { RELATES_TO_RELATIONSHIP, REFERENCE_RELATION } from "matrix-events-sdk";

 import { UnstableValue } from "../NamespacedValue";
 import { MAssetEvent, MLocationEvent, MTimestampEvent } from "./location";

 /**
- * Beacon info and beacon event types as described in MSC3489
- * https://github.com/matrix-org/matrix-spec-proposals/pull/3489
+ * Beacon info and beacon event types as described in MSC3672
+ * https://github.com/matrix-org/matrix-spec-proposals/pull/3672
 */

 /**
@@ -60,16 +60,11 @@ import { MAssetEvent, MLocationEvent, MTimestampEvent } from "./location";
 * }
 */

-/**
- * Variable event type for m.beacon_info
- */
-export const M_BEACON_INFO_VARIABLE = new UnstableValue("m.beacon_info.*", "org.matrix.msc3489.beacon_info.*");
-
 /**
 * Non-variable type for m.beacon_info event content
 */
-export const M_BEACON_INFO = new UnstableValue("m.beacon_info", "org.matrix.msc3489.beacon_info");
-export const M_BEACON = new UnstableValue("m.beacon", "org.matrix.msc3489.beacon");
+export const M_BEACON_INFO = new UnstableValue("m.beacon_info", "org.matrix.msc3672.beacon_info");
+export const M_BEACON = new UnstableValue("m.beacon", "org.matrix.msc3672.beacon");

 export type MBeaconInfoContent = {
    description?: string;
@@ -80,16 +75,11 @@ export type MBeaconInfoContent = {
    live?: boolean;
 };

-export type MBeaconInfoEvent = EitherAnd<
-    { [M_BEACON_INFO.name]: MBeaconInfoContent },
-    { [M_BEACON_INFO.altName]: MBeaconInfoContent }
->;
-
 /**
 * m.beacon_info Event example from the spec
- * https://github.com/matrix-org/matrix-spec-proposals/pull/3489
+ * https://github.com/matrix-org/matrix-spec-proposals/pull/3672
 * {
-    "type": "m.beacon_info.@matthew:matrix.org.1",
+    "type": "m.beacon_info",
    "state_key": "@matthew:matrix.org",
    "content": {
        "m.beacon_info": {
@@ -108,7 +98,7 @@ export type MBeaconInfoEvent = EitherAnd<
 * m.beacon_info.* event content
 */
 export type MBeaconInfoEventContent = &
-    MBeaconInfoEvent &
+    MBeaconInfoContent &
    // creation timestamp of the beacon on the client
    MTimestampEvent &
    // the type of asset being tracked as per MSC3488
@@ -116,7 +106,7 @@ export type MBeaconInfoEventContent = &

 /**
 * m.beacon event example
- * https://github.com/matrix-org/matrix-spec-proposals/pull/3489
+ * https://github.com/matrix-org/matrix-spec-proposals/pull/3672
 *
 * {
    "type": "m.beacon",
@@ -249,21 +249,20 @@ export class AutoDiscovery {

        // Step 7: Copy any other keys directly into the clientConfig. This is for
        // things like custom configuration of services.
-        Object.keys(wellknown)
-            .map((k) => {
-                if (k === "m.homeserver" || k === "m.identity_server") {
-                    // Only copy selected parts of the config to avoid overwriting
-                    // properties computed by the validation logic above.
-                    const notProps = ["error", "state", "base_url"];
-                    for (const prop of Object.keys(wellknown[k])) {
-                        if (notProps.includes(prop)) continue;
-                        clientConfig[k][prop] = wellknown[k][prop];
-                    }
-                } else {
-                    // Just copy the whole thing over otherwise
-                    clientConfig[k] = wellknown[k];
+        Object.keys(wellknown).forEach((k) => {
+            if (k === "m.homeserver" || k === "m.identity_server") {
+                // Only copy selected parts of the config to avoid overwriting
+                // properties computed by the validation logic above.
+                const notProps = ["error", "state", "base_url"];
+                for (const prop of Object.keys(wellknown[k])) {
+                    if (notProps.includes(prop)) continue;
+                    clientConfig[k][prop] = wellknown[k][prop];
                }
-            });
+            } else {
+                // Just copy the whole thing over otherwise
+                clientConfig[k] = wellknown[k];
+            }
+        });

        // Step 8: Give the config to the caller (finally)
        return Promise.resolve(clientConfig);
@@ -48,7 +48,9 @@ import { IRoomEncryption, RoomList } from './crypto/RoomList';
 import { logger } from './logger';
 import { SERVICE_TYPES } from './service-types';
 import {
-    FileType, HttpApiEvent, HttpApiEventHandlerMap,
+    FileType,
+    HttpApiEvent,
+    HttpApiEventHandlerMap,
    IHttpOpts,
    IUpload,
    MatrixError,
@@ -180,7 +182,7 @@ import { MediaHandler } from "./webrtc/mediaHandler";
 import { IRefreshTokenResponse } from "./@types/auth";
 import { TypedEventEmitter } from "./models/typed-event-emitter";
 import { Thread, THREAD_RELATION_TYPE } from "./models/thread";
-import { MBeaconInfoEventContent, M_BEACON_INFO_VARIABLE } from "./@types/beacon";
+import { MBeaconInfoEventContent, M_BEACON_INFO } from "./@types/beacon";

 export type Store = IStore;
 export type SessionStore = WebStorageSessionStore;
@@ -2072,6 +2074,21 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
        return this.crypto.checkDeviceTrust(userId, deviceId);
    }

+    /**
+     * Check whether one of our own devices is cross-signed by our
+     * user's stored keys, regardless of whether we trust those keys yet.
+     *
+     * @param {string} deviceId The ID of the device to check
+     *
+     * @returns {boolean} true if the device is cross-signed
+     */
+    public checkIfOwnDeviceCrossSigned(deviceId: string): boolean {
+        if (!this.crypto) {
+            throw new Error("End-to-end encryption disabled");
+        }
+        return this.crypto.checkIfOwnDeviceCrossSigned(deviceId);
+    }
+
    /**
     * Check the copy of our cross-signing key that we have in the device list and
     * see if we can get the private key. If so, mark it as trusted.
@@ -3400,7 +3417,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     */
    public setIgnoredUsers(userIds: string[], callback?: Callback): Promise<{}> {
        const content = { ignored_users: {} };
-        userIds.map((u) => content.ignored_users[u] = {});
+        userIds.forEach((u) => {
+            content.ignored_users[u] = {};
+        });
        return this.setAccountData("m.ignored_user_list", content, callback);
    }

@@ -3649,39 +3668,30 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     * Create an m.beacon_info event
     * @param {string} roomId
     * @param {MBeaconInfoEventContent} beaconInfoContent
-     * @param {string} eventTypeSuffix - string to suffix event type
-     *  to make event type unique.
-     *  See MSC3489 for more context
-     *  https://github.com/matrix-org/matrix-spec-proposals/pull/3489
     * @returns {ISendEventResponse}
     */
    // eslint-disable-next-line @typescript-eslint/naming-convention
    public async unstable_createLiveBeacon(
        roomId: Room["roomId"],
        beaconInfoContent: MBeaconInfoEventContent,
-        eventTypeSuffix: string,
    ) {
-        const userId = this.getUserId();
-        const eventType = M_BEACON_INFO_VARIABLE.name.replace('*', `${userId}.${eventTypeSuffix}`);
-        return this.unstable_setLiveBeacon(roomId, eventType, beaconInfoContent);
+        return this.unstable_setLiveBeacon(roomId, beaconInfoContent);
    }

    /**
     * Upsert a live beacon event
     * using a specific m.beacon_info.* event variable type
     * @param {string} roomId string
-     * @param {string} beaconInfoEventType event type including variable suffix
     * @param {MBeaconInfoEventContent} beaconInfoContent
     * @returns {ISendEventResponse}
     */
    // eslint-disable-next-line @typescript-eslint/naming-convention
    public async unstable_setLiveBeacon(
        roomId: string,
-        beaconInfoEventType: string,
        beaconInfoContent: MBeaconInfoEventContent,
    ) {
        const userId = this.getUserId();
-        return this.sendStateEvent(roomId, beaconInfoEventType, beaconInfoContent, userId);
+        return this.sendStateEvent(roomId, M_BEACON_INFO.name, beaconInfoContent, userId);
    }

    /**
@@ -3733,7 +3743,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                "rel_type": THREAD_RELATION_TYPE.name,
                "event_id": threadId,
            };
-            const thread = this.getRoom(roomId)?.threads.get(threadId);
+            const thread = this.getRoom(roomId)?.getThread(threadId);
            if (thread) {
                content["m.relates_to"]["m.in_reply_to"] = {
                    "event_id": thread.lastReply((ev: MatrixEvent) => {
@@ -3782,12 +3792,20 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
        }));

        const room = this.getRoom(roomId);
-        const thread = room?.threads.get(threadId);
+        const thread = room?.getThread(threadId);
        if (thread) {
            localEvent.setThread(thread);
-            localEvent.setThreadId(thread.id);
        }

+        // set up re-emitter for this new event - this is normally the job of EventMapper but we don't use it here
+        this.reEmitter.reEmit(localEvent, [
+            MatrixEventEvent.Replaced,
+            MatrixEventEvent.VisibilityChange,
+        ]);
+        room?.reEmitter.reEmit(localEvent, [
+            MatrixEventEvent.BeforeRedaction,
+        ]);
+
        // if this is a relation or redaction of an event
        // that hasn't been sent yet (e.g. with a local id starting with a ~)
        // then listen for the remote echo of that event so that by the time
@@ -5169,7 +5187,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                    limit,
                    Direction.Backward,
                );
-            }).then(async (res: IMessagesResponse) => {
+            }).then((res: IMessagesResponse) => {
                const matrixEvents = res.chunk.map(this.getEventMapper());
                if (res.state) {
                    const stateEvents = res.state.map(this.getEventMapper());
@@ -5178,8 +5196,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa

                const [timelineEvents, threadedEvents] = room.partitionThreadedEvents(matrixEvents);

+                this.processBeaconEvents(room, timelineEvents);
                room.addEventsToTimeline(timelineEvents, true, room.getLiveTimeline());
-                await this.processThreadEvents(room, threadedEvents, true);
+                this.processThreadEvents(room, threadedEvents, true);

                room.oldState.paginationToken = res.end;
                if (res.chunk.length === 0) {
@@ -5277,27 +5296,32 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
        // Where the event is a thread reply (not a root) and running in MSC-enabled mode the Thread timeline only
        // functions contiguously, so we have to jump through some hoops to get our target event in it.
        // XXX: workaround for https://github.com/vector-im/element-meta/issues/150
-        if (Thread.hasServerSideSupport && event.isRelation(THREAD_RELATION_TYPE.name)) {
+        if (Thread.hasServerSideSupport &&
+            this.supportsExperimentalThreads() &&
+            event.isRelation(THREAD_RELATION_TYPE.name)
+        ) {
            const [, threadedEvents] = timelineSet.room.partitionThreadedEvents(events);
-            const thread = await timelineSet.room.createThreadFetchRoot(event.threadRootId, threadedEvents, true);
-
-            let nextBatch: string;
-            const response = await thread.fetchInitialEvents();
-            if (response?.nextBatch) {
-                nextBatch = response.nextBatch;
+            let thread = timelineSet.room.getThread(event.threadRootId);
+            if (!thread) {
+                thread = timelineSet.room.createThread(event.threadRootId, undefined, threadedEvents, true);
            }

            const opts: IRelationsRequestOpts = {
+                direction: Direction.Backward,
                limit: 50,
            };

-            // Fetch events until we find the one we were asked for
+            await thread.fetchInitialEvents();
+            let nextBatch = thread.liveTimeline.getPaginationToken(Direction.Backward);
+
+            // Fetch events until we find the one we were asked for, or we run out of pages
            while (!thread.findEventById(eventId)) {
                if (nextBatch) {
                    opts.from = nextBatch;
                }

                ({ nextBatch } = await thread.fetchEvents(opts));
+                if (!nextBatch) break;
            }

            return thread.liveTimeline;
@@ -5316,7 +5340,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
        const [timelineEvents, threadedEvents] = timelineSet.room.partitionThreadedEvents(events);
        timelineSet.addEventsToTimeline(timelineEvents, true, timeline, res.start);
        // The target event is not in a thread but process the contextual events, so we can show any threads around it.
-        await this.processThreadEvents(timelineSet.room, threadedEvents, true);
+        this.processThreadEvents(timelineSet.room, threadedEvents, true);
+        this.processBeaconEvents(timelineSet.room, timelineEvents);

        // There is no guarantee that the event ended up in "timeline" (we might have switched to a neighbouring
        // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up
@@ -5447,6 +5472,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                // in the notification timeline set
                const timelineSet = eventTimeline.getTimelineSet();
                timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, token);
+                this.processBeaconEvents(timelineSet.room, matrixEvents);

                // if we've hit the end of the timeline, we need to stop trying to
                // paginate. We need to keep the 'forwards' token though, to make sure
@@ -5471,7 +5497,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                opts.limit,
                dir,
                eventTimeline.getFilter(),
-            ).then(async (res) => {
+            ).then((res) => {
                if (res.state) {
                    const roomState = eventTimeline.getState(dir);
                    const stateEvents = res.state.map(this.getEventMapper());
@@ -5483,7 +5509,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                const timelineSet = eventTimeline.getTimelineSet();
                const [timelineEvents, threadedEvents] = timelineSet.room.partitionThreadedEvents(matrixEvents);
                timelineSet.addEventsToTimeline(timelineEvents, backwards, eventTimeline, token);
-                await this.processThreadEvents(room, threadedEvents, backwards);
+                this.processBeaconEvents(timelineSet.room, timelineEvents);
+                this.processThreadEvents(room, threadedEvents, backwards);

                // if we've hit the end of the timeline, we need to stop trying to
                // paginate. We need to keep the 'forwards' token though, to make sure
@@ -6406,12 +6433,18 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
    public async _unstable_getSharedRooms(userId: string): Promise<string[]> { // eslint-disable-line
-        if (!(await this.doesServerSupportUnstableFeature("uk.half-shot.msc2666"))) {
-            throw Error('Server does not support shared_rooms API');
+        const sharedRoomsSupport = await this.doesServerSupportUnstableFeature("uk.half-shot.msc2666");
+        const mutualRoomsSupport = await this.doesServerSupportUnstableFeature("uk.half-shot.msc2666.mutual_rooms");
+
+        if (!sharedRoomsSupport && !mutualRoomsSupport) {
+            throw Error('Server does not support mutual_rooms API');
        }
-        const path = utils.encodeUri("/uk.half-shot.msc2666/user/shared_rooms/$userId", {
-            $userId: userId,
-        });
+
+        const path = utils.encodeUri(
+            `/uk.half-shot.msc2666/user/${mutualRoomsSupport ? 'mutual_rooms' : 'shared_rooms'}/$userId`,
+            { $userId: userId },
+        );
+
        const res = await this.http.authedRequest<{ joined: string[] }>(
            undefined, Method.Get, path, undefined, undefined,
            { prefix: PREFIX_UNSTABLE },
@@ -6581,6 +6614,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
        }
    }

+    /**
+     * Query the server to see if it supports the MSC2457 `logout_devices` parameter when setting password
+     * @return {Promise<boolean>} true if server supports the `logout_devices` parameter
+     */
+    public doesServerSupportLogoutDevices(): Promise<boolean> {
+        return this.isVersionSupported("r0.6.1");
+    }
+
    /**
     * Get if lazy loading members is being used.
     * @return {boolean} Whether or not members are lazy loaded by this client
@@ -6626,7 +6667,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
        eventId: string,
        relationType?: RelationType | string | null,
        eventType?: EventType | string | null,
-        opts: IRelationsRequestOpts = {},
+        opts: IRelationsRequestOpts = { direction: Direction.Backward },
    ): Promise<{
        originalEvent: MatrixEvent;
        events: MatrixEvent[];
@@ -7167,7 +7208,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
        eventId: string,
        relationType?: RelationType | string | null,
        eventType?: EventType | string | null,
-        opts: IRelationsRequestOpts = {},
+        opts: IRelationsRequestOpts = { direction: Direction.Backward },
    ): Promise<IRelationsResponse> {
        const queryString = utils.encodeParams(opts as Record<string, string | number>);

@@ -7242,12 +7283,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     */
    public members(
        roomId: string,
-        includeMembership?: string[],
-        excludeMembership?: string[],
+        includeMembership?: string,
+        excludeMembership?: string,
        atEventId?: string,
        callback?: Callback,
-    ): Promise<{ [userId: string]: IStateEventWithRoomId }> {
-        const queryParams: any = {};
+    ): Promise<{ [userId: string]: IStateEventWithRoomId[] }> {
+        const queryParams: Record<string, string> = {};
        if (includeMembership) {
            queryParams.membership = includeMembership;
        }
@@ -7824,18 +7865,45 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     * Make a request to change your password.
     * @param {Object} authDict
     * @param {string} newPassword The new desired password.
+     * @param {boolean} logoutDevices Should all sessions be logged out after the password change. Defaults to true.
     * @param {module:client.callback} callback Optional.
     * @return {Promise} Resolves: TODO
     * @return {module:http-api.MatrixError} Rejects: with an error response.
     */
-    public setPassword(authDict: any, newPassword: string, callback?: Callback): Promise<any> { // TODO: Types
+    public setPassword(
+        authDict: any,
+        newPassword: string,
+        callback?: Callback,
+    ): Promise<{}>;
+    public setPassword(
+        authDict: any,
+        newPassword: string,
+        logoutDevices: boolean,
+        callback?: Callback,
+    ): Promise<{}>;
+    public setPassword(
+        authDict: any,
+        newPassword: string,
+        logoutDevices?: Callback | boolean,
+        callback?: Callback,
+    ): Promise<{}> {
+        if (typeof logoutDevices === 'function') {
+            callback = logoutDevices;
+        }
+        if (typeof logoutDevices !== 'boolean') {
+            // Use backwards compatible behaviour of not specifying logout_devices
+            // This way it is left up to the server:
+            logoutDevices = undefined;
+        }
+
        const path = "/account/password";
        const data = {
            'auth': authDict,
            'new_password': newPassword,
+            'logout_devices': logoutDevices,
        };

-        return this.http.authedRequest(
+        return this.http.authedRequest<{}>(
            callback, Method.Post, path, null, data,
        );
    }
@@ -8852,12 +8920,18 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
    /**
     * @experimental
     */
-    public async processThreadEvents(
+    public processThreadEvents(room: Room, threadedEvents: MatrixEvent[], toStartOfTimeline: boolean): void {
+        room.processThreadedEvents(threadedEvents, toStartOfTimeline);
+    }
+
+    public processBeaconEvents(
        room: Room,
-        threadedEvents: MatrixEvent[],
-        toStartOfTimeline: boolean,
-    ): Promise<void> {
-        await room.processThreadedEvents(threadedEvents, toStartOfTimeline);
+        events?: MatrixEvent[],
+    ): void {
+        if (!events?.length) {
+            return;
+        }
+        room.currentState.processBeaconEvents(events, this);
    }

    /**
@@ -18,7 +18,7 @@ limitations under the License.

 import { REFERENCE_RELATION } from "matrix-events-sdk";

-import { MBeaconEventContent, MBeaconInfoContent, MBeaconInfoEventContent, M_BEACON_INFO } from "./@types/beacon";
+import { MBeaconEventContent, MBeaconInfoContent, MBeaconInfoEventContent } from "./@types/beacon";
 import { MsgType } from "./@types/event";
 import { TEXT_NODE_TYPE } from "./@types/extensible_events";
 import {
@@ -208,11 +208,9 @@ export const makeBeaconInfoContent: MakeBeaconInfoContent = (
    assetType,
    timestamp,
 ) => ({
-    [M_BEACON_INFO.name]: {
-        description,
-        timeout,
-        live: isLive,
-    },
+    description,
+    timeout,
+    live: isLive,
    [M_TIMESTAMP.name]: timestamp || Date.now(),
    [M_ASSET.name]: {
        type: assetType ?? LocationAssetType.Self,
@@ -227,7 +225,7 @@ export type BeaconInfoState = MBeaconInfoContent & {
 * Flatten beacon info event content
 */
 export const parseBeaconInfoContent = (content: MBeaconInfoEventContent): BeaconInfoState => {
-    const { description, timeout, live } = M_BEACON_INFO.findIn<MBeaconInfoContent>(content);
+    const { description, timeout, live } = content;
    const { type: assetType } = M_ASSET.findIn<MAssetContent>(content);
    const timestamp = M_TIMESTAMP.findIn<number>(content);

@@ -243,14 +241,14 @@ export const parseBeaconInfoContent = (content: MBeaconInfoEventContent): Beacon
 export type MakeBeaconContent = (
    uri: string,
    timestamp: number,
-    beaconInfoId: string,
+    beaconInfoEventId: string,
    description?: string,
 ) => MBeaconEventContent;

 export const makeBeaconContent: MakeBeaconContent = (
    uri,
    timestamp,
-    beaconInfoId,
+    beaconInfoEventId,
    description,
 ) => ({
    [M_LOCATION.name]: {
@@ -260,6 +258,21 @@ export const makeBeaconContent: MakeBeaconContent = (
    [M_TIMESTAMP.name]: timestamp,
    "m.relates_to": {
        rel_type: REFERENCE_RELATION.name,
-        event_id: beaconInfoId,
+        event_id: beaconInfoEventId,
    },
 });
+
+export type BeaconLocationState = MLocationContent & {
+    timestamp: number;
+};
+
+export const parseBeaconContent = (content: MBeaconEventContent): BeaconLocationState => {
+    const { description, uri } = M_LOCATION.findIn<MLocationContent>(content);
+    const timestamp = M_TIMESTAMP.findIn<number>(content);
+
+    return {
+        description,
+        uri,
+        timestamp,
+    };
+};
@@ -73,8 +73,8 @@ export function getHttpUriForMxc(
    const fragmentOffset = serverAndMediaId.indexOf("#");
    let fragment = "";
    if (fragmentOffset >= 0) {
-        fragment = serverAndMediaId.substr(fragmentOffset);
-        serverAndMediaId = serverAndMediaId.substr(0, fragmentOffset);
+        fragment = serverAndMediaId.slice(fragmentOffset);
+        serverAndMediaId = serverAndMediaId.slice(0, fragmentOffset);
    }

    const urlParams = (Object.keys(params).length === 0 ? "" : ("?" + utils.encodeParams(params)));
@@ -309,10 +309,10 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     */
    private getDevicesFromStore(userIds: string[]): DeviceInfoMap {
        const stored: DeviceInfoMap = {};
-        userIds.map((u) => {
+        userIds.forEach((u) => {
            stored[u] = {};
            const devices = this.getStoredDevicesForUser(u) || [];
-            devices.map(function(dev) {
+            devices.forEach(function(dev) {
                stored[u][dev.deviceId] = dev;
            });
        });
@@ -375,9 +375,7 @@ export class BackupManager {
            );
            if (device) {
                sigInfo.device = device;
-                sigInfo.deviceTrust = await this.baseApis.checkDeviceTrust(
-                    this.baseApis.getUserId(), sigInfo.deviceId,
-                );
+                sigInfo.deviceTrust = this.baseApis.checkDeviceTrust(this.baseApis.getUserId(), sigInfo.deviceId);
                try {
                    await verifySignature(
                        this.baseApis.crypto.olmDevice,
@@ -495,7 +493,7 @@ export class BackupManager {
                rooms[roomId] = { sessions: {} };
            }

-            const sessionData = await this.baseApis.crypto.olmDevice.exportInboundGroupSession(
+            const sessionData = this.baseApis.crypto.olmDevice.exportInboundGroupSession(
                session.senderKey, session.sessionId, session.sessionData,
            );
            sessionData.algorithm = MEGOLM_ALGORITHM;
@@ -1026,7 +1026,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
            const decodedBackupKey = new Uint8Array(olmlib.decodeBase64(
                fixedBackupKey || sessionBackupKey,
            ));
-            await builder.addSessionBackupPrivateKeyToCache(decodedBackupKey);
+            builder.addSessionBackupPrivateKeyToCache(decodedBackupKey);
        } else if (this.backupManager.getKeyBackupEnabled()) {
            // key backup is enabled but we don't have a session backup key in SSSS: see if we have one in
            // the cache or the user can provide one, and if so, write it to SSSS
@@ -1423,6 +1423,25 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
        }
    }

+    /**
+     * Check whether one of our own devices is cross-signed by our
+     * user's stored keys, regardless of whether we trust those keys yet.
+     *
+     * @param {string} deviceId The ID of the device to check
+     *
+     * @returns {boolean} true if the device is cross-signed
+     */
+    public checkIfOwnDeviceCrossSigned(deviceId: string): boolean {
+        const device = this.deviceList.getStoredDevice(this.userId, deviceId);
+        const userCrossSigning = this.deviceList.getStoredCrossSigningForUser(this.userId);
+        return userCrossSigning.checkDeviceTrust(
+            userCrossSigning,
+            device,
+            false,
+            true,
+        ).isCrossSigningVerified();
+    }
+
    /*
     * Event handler for DeviceList's userNewDevices event
     */
@@ -228,8 +228,8 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
                // (hence 43 characters long).

                func({
-                    senderKey: key.substr(KEY_INBOUND_SESSION_PREFIX.length, 43),
-                    sessionId: key.substr(KEY_INBOUND_SESSION_PREFIX.length + 44),
+                    senderKey: key.slice(KEY_INBOUND_SESSION_PREFIX.length, KEY_INBOUND_SESSION_PREFIX.length + 43),
+                    sessionId: key.slice(KEY_INBOUND_SESSION_PREFIX.length + 44),
                    sessionData: getJsonItem(this.store, key),
                });
            }
@@ -299,7 +299,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        for (let i = 0; i < this.store.length; ++i) {
            const key = this.store.key(i);
            if (key.startsWith(prefix)) {
-                const roomId = key.substr(prefix.length);
+                const roomId = key.slice(prefix.length);
                result[roomId] = getJsonItem(this.store, key);
            }
        }
@@ -313,8 +313,8 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
        for (const session in sessionsNeedingBackup) {
            if (Object.prototype.hasOwnProperty.call(sessionsNeedingBackup, session)) {
                // see getAllEndToEndInboundGroupSessions for the magic number explanations
-                const senderKey = session.substr(0, 43);
-                const sessionId = session.substr(44);
+                const senderKey = session.slice(0, 43);
+                const sessionId = session.slice(44);
                this.getEndToEndInboundGroupSession(
                    senderKey, sessionId, null,
                    (sessionData) => {
@@ -418,8 +418,8 @@ export class MemoryCryptoStore implements CryptoStore {
            // (hence 43 characters long).

            func({
-                senderKey: key.substr(0, 43),
-                sessionId: key.substr(44),
+                senderKey: key.slice(0, 43),
+                sessionId: key.slice(44),
                sessionData: this.inboundGroupSessions[key],
            });
        }
@@ -482,8 +482,8 @@ export class MemoryCryptoStore implements CryptoStore {
        for (const session in this.sessionsNeedingBackup) {
            if (this.inboundGroupSessions[session]) {
                sessions.push({
-                    senderKey: session.substr(0, 43),
-                    sessionId: session.substr(44),
+                    senderKey: session.slice(0, 43),
+                    sessionId: session.slice(44),
                    sessionData: this.inboundGroupSessions[session],
                });
                if (limit && session.length >= limit) {
@@ -193,6 +193,7 @@ function calculateMAC(olmSAS: OlmSAS, method: string) {
 }

 const calculateKeyAgreement = {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
    "curve25519-hkdf-sha256": function(sas: SAS, olmSAS: OlmSAS, bytes: number): Uint8Array {
        const ourInfo = `${sas.baseApis.getUserId()}|${sas.baseApis.deviceId}|`
              + `${sas.ourSASPubKey}|`;
@@ -796,8 +796,7 @@ export class VerificationRequest<
    }

    private setupTimeout(phase: Phase): void {
-        const shouldTimeout = !this.timeoutTimer && !this.observeOnly &&
-            phase === PHASE_REQUESTED;
+        const shouldTimeout = !this.timeoutTimer && !this.observeOnly && phase === PHASE_REQUESTED;

        if (shouldTimeout) {
            this.timeoutTimer = setTimeout(this.cancelOnTimeout, this.timeout);
@@ -814,15 +813,15 @@ export class VerificationRequest<
        }
    }

-    private cancelOnTimeout = () => {
+    private cancelOnTimeout = async () => {
        try {
            if (this.initiatedByMe) {
-                this.cancel({
+                await this.cancel({
                    reason: "Other party didn't accept in time",
                    code: "m.timeout",
                });
            } else {
-                this.cancel({
+                await this.cancel({
                    reason: "User didn't accept in time",
                    code: "m.timeout",
                });
@@ -25,7 +25,7 @@ export interface MapperOpts {
 }

 export function eventMapperFor(client: MatrixClient, options: MapperOpts): EventMapper {
-    const preventReEmit = Boolean(options.preventReEmit);
+    let preventReEmit = Boolean(options.preventReEmit);
    const decrypt = options.decrypt !== false;

    function mapper(plainOldJsObject: Partial<IEvent>) {
@@ -43,6 +43,8 @@ export function eventMapperFor(client: MatrixClient, options: MapperOpts): Event
        } else {
            // merge the latest unsigned data from the server
            event.setUnsigned({ ...event.getUnsigned(), ...plainOldJsObject.unsigned });
+            // prevent doubling up re-emitters
+            preventReEmit = true;
        }

        const thread = room?.findThreadForEvent(event);
@@ -36,7 +36,7 @@ import {
 function matchesWildcard(actualValue: string, filterValue: string): boolean {
    if (filterValue.endsWith("*")) {
        const typePrefix = filterValue.slice(0, -1);
-        return actualValue.substr(0, typePrefix.length) === typePrefix;
+        return actualValue.slice(0, typePrefix.length) === typePrefix;
    } else {
        return actualValue === filterValue;
    }
@@ -1105,7 +1105,7 @@ export class AbortError extends Error {
 * @return {any} the result of the network operation
 * @throws {ConnectionError} If after maxAttempts the callback still throws ConnectionError
 */
-export async function retryNetworkOperation<T>(maxAttempts: number, callback: () => T): Promise<T> {
+export async function retryNetworkOperation<T>(maxAttempts: number, callback: () => Promise<T>): Promise<T> {
    let attempts = 0;
    let lastConnectionError = null;
    while (attempts < maxAttempts) {
@@ -60,7 +60,11 @@ export enum AuthType {
    Sso = "m.login.sso",
    SsoUnstable = "org.matrix.login.sso",
    Dummy = "m.login.dummy",
-    RegistrationToken = "org.matrix.msc3231.login.registration_token",
+    RegistrationToken = "m.login.registration_token",
+    // For backwards compatability with servers that have not yet updated to
+    // use the stable "m.login.registration_token" type.
+    // The authentication flow is the same in both cases.
+    UnstableRegistrationToken = "org.matrix.msc3231.login.registration_token",
 }

 export interface IAuthDict {
@@ -79,7 +83,8 @@ export interface IAuthDict {
    // eslint-disable-next-line camelcase
    threepid_creds?: any;
    threepidCreds?: any;
-    registrationToken?: string;
+    // For m.login.registration_token type
+    token?: string;
 }

 class NoAuthFlowFoundError extends Error {
@@ -14,22 +14,27 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-import { M_BEACON_INFO } from "../@types/beacon";
-import { BeaconInfoState, parseBeaconInfoContent } from "../content-helpers";
+import { MBeaconEventContent } from "../@types/beacon";
+import { M_TIMESTAMP } from "../@types/location";
+import { BeaconInfoState, BeaconLocationState, parseBeaconContent, parseBeaconInfoContent } from "../content-helpers";
 import { MatrixEvent } from "../matrix";
+import { sortEventsByLatestContentTimestamp } from "../utils";
 import { TypedEventEmitter } from "./typed-event-emitter";

 export enum BeaconEvent {
    New = "Beacon.new",
    Update = "Beacon.update",
    LivenessChange = "Beacon.LivenessChange",
-    Destroy = "Destroy",
+    Destroy = "Beacon.Destroy",
+    LocationUpdate = "Beacon.LocationUpdate",
 }

 export type BeaconEventHandlerMap = {
    [BeaconEvent.Update]: (event: MatrixEvent, beacon: Beacon) => void;
    [BeaconEvent.LivenessChange]: (isLive: boolean, beacon: Beacon) => void;
    [BeaconEvent.Destroy]: (beaconIdentifier: string) => void;
+    [BeaconEvent.LocationUpdate]: (locationState: BeaconLocationState) => void;
+    [BeaconEvent.Destroy]: (beaconIdentifier: string) => void;
 };

 export const isTimestampInDuration = (
@@ -38,16 +43,19 @@ export const isTimestampInDuration = (
    timestamp: number,
 ): boolean => timestamp >= startTimestamp && startTimestamp + durationMs >= timestamp;

-export const isBeaconInfoEventType = (type: string) =>
-    type.startsWith(M_BEACON_INFO.name) ||
-    type.startsWith(M_BEACON_INFO.altName);
+// beacon info events are uniquely identified by
+// `<roomId>_<state_key>`
+export type BeaconIdentifier = string;
+export const getBeaconInfoIdentifier = (event: MatrixEvent): BeaconIdentifier =>
+    `${event.getRoomId()}_${event.getStateKey()}`;

-// https://github.com/matrix-org/matrix-spec-proposals/pull/3489
+// https://github.com/matrix-org/matrix-spec-proposals/pull/3672
 export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.New>, BeaconEventHandlerMap> {
    public readonly roomId: string;
    private _beaconInfo: BeaconInfoState;
    private _isLive: boolean;
    private livenessWatchInterval: number;
+    private _latestLocationState: BeaconLocationState | undefined;

    constructor(
        private rootEvent: MatrixEvent,
@@ -61,8 +69,8 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
        return this._isLive;
    }

-    public get identifier(): string {
-        return this.beaconInfoEventType;
+    public get identifier(): BeaconIdentifier {
+        return getBeaconInfoIdentifier(this.rootEvent);
    }

    public get beaconInfoId(): string {
@@ -81,14 +89,23 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
        return this._beaconInfo;
    }

+    public get latestLocationState(): BeaconLocationState | undefined {
+        return this._latestLocationState;
+    }
+
    public update(beaconInfoEvent: MatrixEvent): void {
-        if (beaconInfoEvent.getType() !== this.beaconInfoEventType) {
+        if (getBeaconInfoIdentifier(beaconInfoEvent) !== this.identifier) {
            throw new Error('Invalid updating event');
        }
+        // don't update beacon with an older event
+        if (beaconInfoEvent.event.origin_server_ts < this.rootEvent.event.origin_server_ts) {
+            return;
+        }
        this.rootEvent = beaconInfoEvent;
        this.setBeaconInfo(this.rootEvent);

        this.emit(BeaconEvent.Update, beaconInfoEvent, this);
+        this.clearLatestLocation();
    }

    public destroy(): void {
@@ -109,14 +126,51 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
            clearInterval(this.livenessWatchInterval);
        }

+        this.checkLiveness();
        if (this.isLive) {
-            const expiryInMs = (this._beaconInfo?.timestamp + this._beaconInfo?.timeout + 1) - Date.now();
+            const expiryInMs = (this._beaconInfo?.timestamp + this._beaconInfo?.timeout) - Date.now();
            if (expiryInMs > 1) {
-                this.livenessWatchInterval = setInterval(this.checkLiveness.bind(this), expiryInMs);
+                this.livenessWatchInterval = setInterval(
+                    () => { this.monitorLiveness(); },
+                    expiryInMs,
+                );
            }
        }
    }

+    /**
+     * Process Beacon locations
+     * Emits BeaconEvent.LocationUpdate
+     */
+    public addLocations(beaconLocationEvents: MatrixEvent[]): void {
+        // discard locations for beacons that are not live
+        if (!this.isLive) {
+            return;
+        }
+
+        const validLocationEvents = beaconLocationEvents.filter(event => {
+            const content = event.getContent<MBeaconEventContent>();
+            const timestamp = M_TIMESTAMP.findIn<number>(content);
+            return (
+                // only include positions that were taken inside the beacon's live period
+                isTimestampInDuration(this._beaconInfo.timestamp, this._beaconInfo.timeout, timestamp) &&
+                // ignore positions older than our current latest location
+                (!this.latestLocationState || timestamp > this.latestLocationState.timestamp)
+            );
+        });
+        const latestLocationEvent = validLocationEvents.sort(sortEventsByLatestContentTimestamp)?.[0];
+
+        if (latestLocationEvent) {
+            this._latestLocationState = parseBeaconContent(latestLocationEvent.getContent());
+            this.emit(BeaconEvent.LocationUpdate, this.latestLocationState);
+        }
+    }
+
+    private clearLatestLocation = () => {
+        this._latestLocationState = undefined;
+        this.emit(BeaconEvent.LocationUpdate, this.latestLocationState);
+    };
+
    private setBeaconInfo(event: MatrixEvent): void {
        this._beaconInfo = parseBeaconInfoContent(event.getContent());
        this.checkLiveness();
@@ -852,14 +852,13 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
        }
        let relationsWithEventType = relationsWithRelType[eventType];

-        let relatesToEvent: MatrixEvent;
        if (!relationsWithEventType) {
            relationsWithEventType = relationsWithRelType[eventType] = new Relations(
                relationType,
                eventType,
                this.room,
            );
-            relatesToEvent = this.findEventById(relatesToEventId) || this.room.getPendingEvent(relatesToEventId);
+            const relatesToEvent = this.findEventById(relatesToEventId) || this.room.getPendingEvent(relatesToEventId);
            if (relatesToEvent) {
                relationsWithEventType.setTargetEvent(relatesToEvent);
            }
@@ -1303,8 +1303,7 @@ export class MatrixEvent extends TypedEventEmitter<EmittedEvents, MatrixEventHan
    public isRelation(relType: string = undefined): boolean {
        // Relation info is lifted out of the encrypted content when sent to
        // encrypted rooms, so we have to check `getWireContent` for this.
-        const content = this.getWireContent();
-        const relation = content && content["m.relates_to"];
+        const relation = this.getWireContent()?.["m.relates_to"];
        return relation && relation.rel_type && relation.event_id &&
            ((relType && relation.rel_type === relType) || !relType);
    }
@@ -1336,6 +1335,10 @@ export class MatrixEvent extends TypedEventEmitter<EmittedEvents, MatrixEventHan
        if (this.isRedacted() && newEvent) {
            return;
        }
+        // don't allow state events to be replaced using this mechanism as per MSC2676
+        if (this.isState()) {
+            return;
+        }
        if (this._replacingEvent !== newEvent) {
            this._replacingEvent = newEvent;
            this.emit(MatrixEventEvent.Replaced, this);
@@ -22,12 +22,14 @@ import { RoomMember } from "./room-member";
 import { logger } from '../logger';
 import * as utils from "../utils";
 import { EventType } from "../@types/event";
-import { MatrixEvent } from "./event";
+import { MatrixEvent, MatrixEventEvent } from "./event";
 import { MatrixClient } from "../client";
 import { GuestAccess, HistoryVisibility, IJoinRuleEventContent, JoinRule } from "../@types/partials";
 import { TypedEventEmitter } from "./typed-event-emitter";
-import { Beacon, BeaconEvent, isBeaconInfoEventType, BeaconEventHandlerMap } from "./beacon";
+import { Beacon, BeaconEvent, BeaconEventHandlerMap } from "./beacon";
 import { TypedReEmitter } from "../ReEmitter";
+import { M_BEACON, M_BEACON_INFO } from "../@types/beacon";
+import { getBeaconInfoIdentifier, BeaconIdentifier } from "./beacon";

 // possible statuses for out-of-band member loading
 enum OobStatus {
@@ -80,8 +82,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
    public events = new Map<string, Map<string, MatrixEvent>>(); // Map<eventType, Map<stateKey, MatrixEvent>>
    public paginationToken: string = null;

-    public readonly beacons = new Map<string, Beacon>();
-    private liveBeaconIds: string[] = [];
+    public readonly beacons = new Map<BeaconIdentifier, Beacon>();
+    private _liveBeaconIds: BeaconIdentifier[] = [];

    /**
     * Construct room state.
@@ -248,6 +250,10 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
        return !!this.liveBeaconIds?.length;
    }

+    public get liveBeaconIds(): BeaconIdentifier[] {
+        return this._liveBeaconIds;
+    }
+
    /**
     * Creates a copy of this room state so that mutations to either won't affect the other.
     * @return {RoomState} the copy of the room state
@@ -330,7 +336,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
                return;
            }

-            if (isBeaconInfoEventType(event.getType())) {
+            if (M_BEACON_INFO.matches(event.getType())) {
                this.setBeacon(event);
            }

@@ -404,6 +410,51 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
        this.emit(RoomStateEvent.Update, this);
    }

+    public processBeaconEvents(events: MatrixEvent[], matrixClient: MatrixClient): void {
+        if (
+            !events.length ||
+            // discard locations if we have no beacons
+            !this.beacons.size
+        ) {
+            return;
+        }
+
+        const beaconByEventIdDict: Record<string, Beacon> =
+            [...this.beacons.values()].reduce((dict, beacon) => ({ ...dict, [beacon.beaconInfoId]: beacon }), {});
+
+        const processBeaconRelation = (beaconInfoEventId: string, event: MatrixEvent): void => {
+            if (!M_BEACON.matches(event.getType())) {
+                return;
+            }
+
+            const beacon = beaconByEventIdDict[beaconInfoEventId];
+
+            if (beacon) {
+                beacon.addLocations([event]);
+            }
+        };
+
+        events.forEach((event: MatrixEvent) => {
+            const relatedToEventId = event.getRelation()?.event_id;
+            // not related to a beacon we know about
+            // discard
+            if (!beaconByEventIdDict[relatedToEventId]) {
+                return;
+            }
+
+            matrixClient.decryptEventIfNeeded(event);
+
+            if (event.isBeingDecrypted() || event.isDecryptionFailure()) {
+                // add an event listener for once the event is decrypted.
+                event.once(MatrixEventEvent.Decrypted, async () => {
+                    processBeaconRelation(relatedToEventId, event);
+                });
+            } else {
+                processBeaconRelation(relatedToEventId, event);
+            }
+        });
+    }
+
    /**
     * Looks up a member by the given userId, and if it doesn't exist,
     * create it and emit the `RoomState.newMember` event.
@@ -437,12 +488,16 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     * @experimental
     */
    private setBeacon(event: MatrixEvent): void {
-        if (this.beacons.has(event.getType())) {
-            const beacon = this.beacons.get(event.getType());
+        const beaconIdentifier = getBeaconInfoIdentifier(event);
+
+        if (this.beacons.has(beaconIdentifier)) {
+            const beacon = this.beacons.get(beaconIdentifier);

            if (event.isRedacted()) {
-                beacon.destroy();
-                this.beacons.delete(event.getType());
+                if (beacon.beaconInfoId === event.getRedactionEvent()?.['redacts']) {
+                    beacon.destroy();
+                    this.beacons.delete(beaconIdentifier);
+                }
                return;
            }

@@ -464,25 +519,22 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>

        this.emit(BeaconEvent.New, event, beacon);
        beacon.on(BeaconEvent.LivenessChange, this.onBeaconLivenessChange.bind(this));
-        this.beacons.set(beacon.beaconInfoEventType, beacon);
+        beacon.on(BeaconEvent.Destroy, this.onBeaconLivenessChange.bind(this));
+
+        this.beacons.set(beacon.identifier, beacon);
    }

    /**
     * @experimental
     * Check liveness of room beacons
-     * emit RoomStateEvent.BeaconLiveness when
-     * roomstate.hasLiveBeacons has changed
+     * emit RoomStateEvent.BeaconLiveness event
     */
    private onBeaconLivenessChange(): void {
-        const prevHasLiveBeacons = !!this.liveBeaconIds?.length;
-        this.liveBeaconIds = Array.from(this.beacons.values())
+        this._liveBeaconIds = Array.from(this.beacons.values())
            .filter(beacon => beacon.isLive)
-            .map(beacon => beacon.beaconInfoId);
+            .map(beacon => beacon.identifier);

-        const hasLiveBeacons = !!this.liveBeaconIds.length;
-        if (prevHasLiveBeacons !== hasLiveBeacons) {
-            this.emit(RoomStateEvent.BeaconLiveness, this, hasLiveBeacons);
-        }
+        this.emit(RoomStateEvent.BeaconLiveness, this, this.hasLiveBeacons);
    }

    private getStateEventMatching(event: MatrixEvent): MatrixEvent | null {
@@ -22,7 +22,7 @@ import { EventTimelineSet, DuplicateStrategy } from "./event-timeline-set";
 import { Direction, EventTimeline } from "./event-timeline";
 import { getHttpUriForMxc } from "../content-repo";
 import * as utils from "../utils";
-import { defer, normalize } from "../utils";
+import { normalize } from "../utils";
 import { IEvent, IThreadBundledRelationship, MatrixEvent, MatrixEventEvent, MatrixEventHandlerMap } from "./event";
 import { EventStatus } from "./event-status";
 import { RoomMember } from "./room-member";
@@ -46,8 +46,8 @@ import {
    FILTER_RELATED_BY_SENDERS,
    ThreadFilterType,
 } from "./thread";
-import { Method } from "../http-api";
 import { TypedEventEmitter } from "./typed-event-emitter";
+import { IStateEventWithRoomId } from "../@types/search";

 // 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
@@ -55,8 +55,8 @@ import { TypedEventEmitter } from "./typed-event-emitter";
 // room versions which are considered okay for people to run without being asked
 // to upgrade (ie: "stable"). Eventually, we should remove these when all homeservers
 // return an m.room_versions capability.
-const KNOWN_SAFE_ROOM_VERSION = '6';
-const SAFE_ROOM_VERSIONS = ['1', '2', '3', '4', '5', '6'];
+const KNOWN_SAFE_ROOM_VERSION = '9';
+const SAFE_ROOM_VERSIONS = ['1', '2', '3', '4', '5', '6', '7', '8', '9'];

 function synthesizeReceipt(userId: string, event: MatrixEvent, receiptType: string): MatrixEvent {
    // console.log("synthesizing receipt for "+event.getId());
@@ -214,8 +214,6 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
    private getTypeWarning = false;
    private getVersionWarning = false;
    private membersPromise?: Promise<boolean>;
-    // Map from threadId to pending Thread instance created by createThreadFetchRoot
-    private threadPromises = new Map<string, Promise<Thread>>();

    // XXX: These should be read-only
    /**
@@ -266,7 +264,7 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
    /**
     * @experimental
     */
-    public threads = new Map<string, Thread>();
+    private threads = new Map<string, Thread>();
    public lastThread: Thread;

    /**
@@ -788,16 +786,9 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
        }
    }

-    private async loadMembersFromServer(): Promise<IEvent[]> {
+    private async loadMembersFromServer(): Promise<IStateEventWithRoomId[]> {
        const lastSyncToken = this.client.store.getSyncToken();
-        const queryString = utils.encodeParams({
-            not_membership: "leave",
-            at: lastSyncToken,
-        });
-        const path = utils.encodeUri("/rooms/$roomId/members?" + queryString,
-            { $roomId: this.roomId });
-        const http = this.client.http;
-        const response = await http.authedRequest<{ chunk: IEvent[] }>(undefined, Method.Get, path);
+        const response = await this.client.members(this.roomId, undefined, "leave", lastSyncToken);
        return response.chunk;
    }

@@ -806,12 +797,13 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
        let fromServer = false;
        let rawMembersEvents = await this.client.store.getOutOfBandMembers(this.roomId);
        // If the room is encrypted, we always fetch members from the server at
-        // least once, in case the latest state wasn't persisted properly.  Note
+        // least once, in case the latest state wasn't persisted properly. Note
        // that this function is only called once (unless loading the members
        // fails), since loadMembersIfNeeded always returns this.membersPromise
        // if set, which will be the result of the first (successful) call.
        if (rawMembersEvents === null ||
-            (this.client.isCryptoEnabled() && this.client.isRoomEncrypted(this.roomId))) {
+            (this.client.isCryptoEnabled() && this.client.isRoomEncrypted(this.roomId))
+        ) {
            fromServer = true;
            rawMembersEvents = await this.loadMembersFromServer();
            logger.log(`LL: got ${rawMembersEvents.length} ` +
@@ -857,7 +849,7 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
            if (fromServer) {
                const oobMembers = this.currentState.getMembers()
                    .filter((m) => m.isOutOfBand())
-                    .map((m) => m.events.member.event as IEvent);
+                    .map((m) => m.events.member.event as IStateEventWithRoomId);
                logger.log(`LL: telling store to write ${oobMembers.length}`
                    + ` members for room ${this.roomId}`);
                const store = this.client.store;
@@ -1214,9 +1206,7 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
     * @experimental
     */
    public getThread(eventId: string): Thread {
-        return this.getThreads().find(thread => {
-            return thread.id === eventId;
-        });
+        return this.threads.get(eventId);
    }

    /**
@@ -1474,7 +1464,7 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
    public threadsReady = false;

    public async fetchRoomThreads(): Promise<void> {
-        if (this.threadsReady) {
+        if (this.threadsReady || !this.client.supportsExperimentalThreads()) {
            return;
        }

@@ -1530,7 +1520,7 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
            }

            if (!this.getThread(rootEvent.getId())) {
-                this.createThread(rootEvent, [], true);
+                this.createThread(rootEvent.getId(), rootEvent, [], true);
            }
        }

@@ -1612,16 +1602,6 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
            };
        }

-        // A reply directly to a thread response is shown as part of the thread only, this is to provide a better
-        // experience when communicating with users using clients without full threads support
-        if (parentEvent?.isThreadRelation) {
-            return {
-                shouldLiveInRoom: false,
-                shouldLiveInThread: true,
-                threadId: parentEvent.threadRootId,
-            };
-        }
-
        // We've exhausted all scenarios, can safely assume that this event should live in the room timeline only
        return {
            shouldLiveInRoom: true,
@@ -1636,58 +1616,14 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
        return threadId ? this.getThread(threadId) : null;
    }

-    public async createThreadFetchRoot(
-        threadId: string,
-        events?: MatrixEvent[],
-        toStartOfTimeline?: boolean,
-    ): Promise<Thread | null> {
+    private addThreadedEvents(threadId: string, events: MatrixEvent[], toStartOfTimeline = false): void {
        let thread = this.getThread(threadId);

-        if (!thread) {
-            const deferred = defer<Thread | null>();
-            this.threadPromises.set(threadId, deferred.promise);
-
-            let rootEvent = this.findEventById(threadId);
-            // If the rootEvent does not exist in the local stores, then fetch it from the server.
-            try {
-                const eventData = await this.client.fetchRoomEvent(this.roomId, threadId);
-                const mapper = this.client.getEventMapper();
-                rootEvent = mapper(eventData); // will merge with existing event object if such is known
-            } catch (e) {
-                logger.error("Failed to fetch thread root to construct thread with", e);
-            } finally {
-                this.threadPromises.delete(threadId);
-                // The root event might be not be visible to the person requesting it.
-                // If it wasn't fetched successfully the thread will work in "limited" mode and won't
-                // benefit from all the APIs a homeserver can provide to enhance the thread experience
-                thread = this.createThread(rootEvent, events, toStartOfTimeline);
-                if (thread) {
-                    rootEvent.setThread(thread);
-                }
-                deferred.resolve(thread);
-            }
-        }
-
-        return thread;
-    }
-
-    private async addThreadedEvents(events: MatrixEvent[], threadId: string, toStartOfTimeline = false): Promise<void> {
-        let thread = this.getThread(threadId);
-        if (this.threadPromises.has(threadId)) {
-            thread = await this.threadPromises.get(threadId);
-        }
-
-        events = events.filter(e => e.getId() !== threadId); // filter out any root events
-
        if (thread) {
-            for (const event of events) {
-                await thread.addEvent(event, toStartOfTimeline);
-            }
+            thread.addEvents(events, toStartOfTimeline);
        } else {
-            thread = await this.createThreadFetchRoot(threadId, events, toStartOfTimeline);
-        }
-
-        if (thread) {
+            const rootEvent = this.findEventById(threadId) ?? events.find(e => e.getId() === threadId);
+            thread = this.createThread(threadId, rootEvent, events, toStartOfTimeline);
            this.emit(ThreadEvent.Update, thread);
        }
    }
@@ -1696,28 +1632,29 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
     * Adds events to a thread's timeline. Will fire "Thread.update"
     * @experimental
     */
-    public async processThreadedEvents(events: MatrixEvent[], toStartOfTimeline: boolean): Promise<unknown> {
+    public processThreadedEvents(events: MatrixEvent[], toStartOfTimeline: boolean): void {
        events.forEach(this.applyRedaction);

        const eventsByThread: { [threadId: string]: MatrixEvent[] } = {};
        for (const event of events) {
-            const { threadId } = this.eventShouldLiveIn(event);
-            if (!eventsByThread[threadId]) {
+            const { threadId, shouldLiveInThread } = this.eventShouldLiveIn(event);
+            if (shouldLiveInThread && !eventsByThread[threadId]) {
                eventsByThread[threadId] = [];
            }
-            eventsByThread[threadId].push(event);
+            eventsByThread[threadId]?.push(event);
        }

-        return Promise.all(Object.entries(eventsByThread).map(([threadId, events]) => (
-            this.addThreadedEvents(events, threadId, toStartOfTimeline)
-        )));
+        Object.entries(eventsByThread).map(([threadId, events]) => (
+            this.addThreadedEvents(threadId, events, toStartOfTimeline)
+        ));
    }

    public createThread(
+        threadId: string,
        rootEvent: MatrixEvent | undefined,
        events: MatrixEvent[] = [],
        toStartOfTimeline: boolean,
-    ): Thread | undefined {
+    ): Thread {
        if (rootEvent) {
            const tl = this.getTimelineForEvent(rootEvent.getId());
            const relatedEvents = tl?.getTimelineSet().getAllRelationsEventForEvent(rootEvent.getId());
@@ -1726,45 +1663,44 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
            }
        }

-        const thread = new Thread(rootEvent, {
+        const thread = new Thread(threadId, rootEvent, {
            initialEvents: events,
            room: this,
            client: this.client,
        });
+
        // If we managed to create a thread and figure out its `id` then we can use it
-        if (thread.id) {
-            this.threads.set(thread.id, thread);
-            this.reEmitter.reEmit(thread, [
-                ThreadEvent.Update,
-                ThreadEvent.NewReply,
-                RoomEvent.Timeline,
-                RoomEvent.TimelineReset,
-            ]);
+        this.threads.set(thread.id, thread);
+        this.reEmitter.reEmit(thread, [
+            ThreadEvent.Update,
+            ThreadEvent.NewReply,
+            RoomEvent.Timeline,
+            RoomEvent.TimelineReset,
+        ]);

-            if (!this.lastThread || this.lastThread.rootEvent?.localTimestamp < rootEvent?.localTimestamp) {
-                this.lastThread = thread;
-            }
-
-            this.emit(ThreadEvent.New, thread, toStartOfTimeline);
-
-            if (this.threadsReady) {
-                this.threadsTimelineSets.forEach(timelineSet => {
-                    if (thread.rootEvent) {
-                        if (Thread.hasServerSideSupport) {
-                            timelineSet.addLiveEvent(thread.rootEvent);
-                        } else {
-                            timelineSet.addEventToTimeline(
-                                thread.rootEvent,
-                                timelineSet.getLiveTimeline(),
-                                toStartOfTimeline,
-                            );
-                        }
-                    }
-                });
-            }
-
-            return thread;
+        if (!this.lastThread || this.lastThread.rootEvent?.localTimestamp < rootEvent?.localTimestamp) {
+            this.lastThread = thread;
        }
+
+        this.emit(ThreadEvent.New, thread, toStartOfTimeline);
+
+        if (this.threadsReady) {
+            this.threadsTimelineSets.forEach(timelineSet => {
+                if (thread.rootEvent) {
+                    if (Thread.hasServerSideSupport) {
+                        timelineSet.addLiveEvent(thread.rootEvent);
+                    } else {
+                        timelineSet.addEventToTimeline(
+                            thread.rootEvent,
+                            timelineSet.getLiveTimeline(),
+                            toStartOfTimeline,
+                        );
+                    }
+                }
+            });
+        }
+
+        return thread;
    }

    private applyRedaction = (event: MatrixEvent): void => {
@@ -2205,7 +2141,6 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
        }

        const threadRoots = this.findThreadRoots(events);
-        const threadInfos = events.map(e => this.eventShouldLiveIn(e, events, threadRoots));
        const eventsByThread: { [threadId: string]: MatrixEvent[] } = {};

        for (let i = 0; i < events.length; i++) {
@@ -2216,14 +2151,12 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
                shouldLiveInRoom,
                shouldLiveInThread,
                threadId,
-            } = threadInfos[i];
+            } = this.eventShouldLiveIn(events[i], events, threadRoots);

-            if (shouldLiveInThread) {
-                if (!eventsByThread[threadId]) {
-                    eventsByThread[threadId] = [];
-                }
-                eventsByThread[threadId].push(events[i]);
+            if (shouldLiveInThread && !eventsByThread[threadId]) {
+                eventsByThread[threadId] = [];
            }
+            eventsByThread[threadId]?.push(events[i]);

            if (shouldLiveInRoom) {
                this.addLiveEvent(events[i], duplicateStrategy, fromCache);
@@ -2231,7 +2164,7 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
        }

        Object.entries(eventsByThread).forEach(([threadId, threadEvents]) => {
-            this.addThreadedEvents(threadEvents, threadId, false);
+            this.addThreadedEvents(threadId, threadEvents, false);
        });
    }

@@ -2339,22 +2272,27 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
        // set fake stripped state events if this is an invite room so logic remains
        // consistent elsewhere.
        const membershipEvent = this.currentState.getStateEvents(EventType.RoomMember, this.myUserId);
-        if (membershipEvent && membershipEvent.getContent().membership === "invite") {
-            const strippedStateEvents = membershipEvent.getUnsigned().invite_room_state || [];
-            strippedStateEvents.forEach((strippedEvent) => {
-                const existingEvent = this.currentState.getStateEvents(strippedEvent.type, strippedEvent.state_key);
-                if (!existingEvent) {
-                    // set the fake stripped event instead
-                    this.currentState.setStateEvents([new MatrixEvent({
-                        type: strippedEvent.type,
-                        state_key: strippedEvent.state_key,
-                        content: strippedEvent.content,
-                        event_id: "$fake" + Date.now(),
-                        room_id: this.roomId,
-                        user_id: this.myUserId, // technically a lie
-                    })]);
-                }
-            });
+        if (membershipEvent) {
+            const membership = membershipEvent.getContent().membership;
+            this.updateMyMembership(membership);
+
+            if (membership === "invite") {
+                const strippedStateEvents = membershipEvent.getUnsigned().invite_room_state || [];
+                strippedStateEvents.forEach((strippedEvent) => {
+                    const existingEvent = this.currentState.getStateEvents(strippedEvent.type, strippedEvent.state_key);
+                    if (!existingEvent) {
+                        // set the fake stripped event instead
+                        this.currentState.setStateEvents([new MatrixEvent({
+                            type: strippedEvent.type,
+                            state_key: strippedEvent.state_key,
+                            content: strippedEvent.content,
+                            event_id: "$fake" + Date.now(),
+                            room_id: this.roomId,
+                            user_id: this.myUserId, // technically a lie
+                        })]);
+                    }
+                });
+            }
        }

        const oldName = this.name;
@@ -70,12 +70,11 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
    public readonly room: Room;
    public readonly client: MatrixClient;

-    public initialEventsFetched = false;
-
-    public readonly id: string;
+    public initialEventsFetched = !Thread.hasServerSideSupport;

    constructor(
-        public readonly rootEvent: MatrixEvent | undefined,
+        public readonly id: string,
+        public rootEvent: MatrixEvent | undefined,
        opts: IThreadOpts,
    ) {
        super();
@@ -95,15 +94,37 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
        ]);

        this.room.on(MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
+        this.room.on(RoomEvent.Redaction, this.onRedaction);
        this.room.on(RoomEvent.LocalEchoUpdated, this.onEcho);
        this.timelineSet.on(RoomEvent.Timeline, this.onEcho);

-        // If we weren't able to find the root event, it's probably missing,
-        // and we define the thread ID from one of the thread relation
-        this.id = rootEvent?.getId() ?? opts?.initialEvents?.find(event => event.isThreadRelation)?.relationEventId;
-        this.initialiseThread(this.rootEvent);
+        if (opts.initialEvents) {
+            this.addEvents(opts.initialEvents, false);
+        }
+        // even if this thread is thought to be originating from this client, we initialise it as we may be in a
+        // gappy sync and a thread around this event may already exist.
+        this.initialiseThread();

-        opts?.initialEvents?.forEach(event => this.addEvent(event, false));
+        this.rootEvent?.setThread(this);
+    }
+
+    private async fetchRootEvent(): Promise<void> {
+        this.rootEvent = this.room.findEventById(this.id);
+        // If the rootEvent does not exist in the local stores, then fetch it from the server.
+        try {
+            const eventData = await this.client.fetchRoomEvent(this.roomId, this.id);
+            const mapper = this.client.getEventMapper();
+            this.rootEvent = mapper(eventData); // will merge with existing event object if such is known
+        } catch (e) {
+            logger.error("Failed to fetch thread root to construct thread with", e);
+        }
+
+        // The root event might be not be visible to the person requesting it.
+        // If it wasn't fetched successfully the thread will work in "limited" mode and won't
+        // benefit from all the APIs a homeserver can provide to enhance the thread experience
+        this.rootEvent?.setThread(this);
+
+        this.emit(ThreadEvent.Update, this);
    }

    public static setServerSideSupport(hasServerSideSupport: boolean, useStable: boolean): void {
@@ -115,23 +136,25 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
        }
    }

-    private onBeforeRedaction = (event: MatrixEvent) => {
+    private onBeforeRedaction = (event: MatrixEvent, redaction: MatrixEvent) => {
        if (event?.isRelation(THREAD_RELATION_TYPE.name) &&
-            this.room.eventShouldLiveIn(event).threadId === this.id
+            this.room.eventShouldLiveIn(event).threadId === this.id &&
+            event.getId() !== this.id && // the root event isn't counted in the length so ignore this redaction
+            !redaction.status // only respect it when it succeeds
        ) {
            this.replyCount--;
            this.emit(ThreadEvent.Update, this);
        }
+    };

-        if (this.lastEvent?.getId() === event.getId()) {
-            const events = [...this.timelineSet.getLiveTimeline().getEvents()].reverse();
-            this.lastEvent = events.find(e => (
-                !e.isRedacted() &&
-                e.getId() !== event.getId() &&
-                e.isRelation(THREAD_RELATION_TYPE.name)
-            )) ?? this.rootEvent;
-            this.emit(ThreadEvent.NewReply, this, this.lastEvent);
-        }
+    private onRedaction = (event: MatrixEvent) => {
+        if (event.threadRootId !== this.id) return; // ignore redactions for other timelines
+        const events = [...this.timelineSet.getLiveTimeline().getEvents()].reverse();
+        this.lastEvent = events.find(e => (
+            !e.isRedacted() &&
+            e.isRelation(THREAD_RELATION_TYPE.name)
+        )) ?? this.rootEvent;
+        this.emit(ThreadEvent.Update, this);
    };

    private onEcho = (event: MatrixEvent) => {
@@ -142,7 +165,7 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
        // when threads are used over federation. That could result in the reply
        // count value drifting away from the value returned by the server
        const isThreadReply = event.isRelation(THREAD_RELATION_TYPE.name);
-        if (!this.lastEvent || (isThreadReply
+        if (!this.lastEvent || this.lastEvent.isRedacted() || (isThreadReply
            && (event.getId() !== this.lastEvent.getId())
            && (event.localTimestamp > this.lastEvent.localTimestamp))
        ) {
@@ -177,6 +200,11 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
        }
    }

+    public addEvents(events: MatrixEvent[], toStartOfTimeline: boolean): void {
+        events.forEach(ev => this.addEvent(ev, toStartOfTimeline, false));
+        this.emit(ThreadEvent.Update, this);
+    }
+
    /**
     * Add an event to the thread and updates
     * the tail/root references if needed
@@ -184,43 +212,59 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
     * @param event The event to add
     * @param {boolean} toStartOfTimeline whether the event is being added
     * to the start (and not the end) of the timeline.
+     * @param {boolean} emit whether to emit the Update event if the thread was updated or not.
     */
-    public async addEvent(event: MatrixEvent, toStartOfTimeline: boolean): Promise<void> {
+    public addEvent(event: MatrixEvent, toStartOfTimeline: boolean, emit = true): void {
+        event.setThread(this);
+
+        if (!this._currentUserParticipated && event.getSender() === this.client.getUserId()) {
+            this._currentUserParticipated = true;
+        }
+
+        // Add all annotations and replace relations to the timeline so that the relations are processed accordingly
+        if ([RelationType.Annotation, RelationType.Replace].includes(event.getRelation()?.rel_type as RelationType)) {
+            this.addEventToTimeline(event, toStartOfTimeline);
+            return;
+        }
+
        // Add all incoming events to the thread's timeline set when there's  no server support
        if (!Thread.hasServerSideSupport) {
            // all the relevant membership info to hydrate events with a sender
            // is held in the main room timeline
            // We want to fetch the room state from there and pass it down to this thread
            // timeline set to let it reconcile an event with its relevant RoomMember
-
-            event.setThread(this);
            this.addEventToTimeline(event, toStartOfTimeline);

-            await this.client.decryptEventIfNeeded(event, {});
+            this.client.decryptEventIfNeeded(event, {});
        } else if (!toStartOfTimeline &&
            this.initialEventsFetched &&
-            event.localTimestamp > this.lastReply().localTimestamp
+            event.localTimestamp > this.lastReply()?.localTimestamp
        ) {
-            await this.fetchEditsWhereNeeded(event);
+            this.fetchEditsWhereNeeded(event);
            this.addEventToTimeline(event, false);
        }

-        if (!this._currentUserParticipated && event.getSender() === this.client.getUserId()) {
-            this._currentUserParticipated = true;
-        }
-
        // If no thread support exists we want to count all thread relation
        // added as a reply. We can't rely on the bundled relationships count
-        if (!Thread.hasServerSideSupport && event.isRelation(THREAD_RELATION_TYPE.name)) {
+        if ((!Thread.hasServerSideSupport || !this.rootEvent) && event.isRelation(THREAD_RELATION_TYPE.name)) {
            this.replyCount++;
        }

-        this.emit(ThreadEvent.Update, this);
+        if (emit) {
+            this.emit(ThreadEvent.Update, this);
+        }
    }

-    private initialiseThread(rootEvent: MatrixEvent | undefined): void {
-        const bundledRelationship = rootEvent
-            ?.getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);
+    private getRootEventBundledRelationship(rootEvent = this.rootEvent): IThreadBundledRelationship {
+        return rootEvent?.getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);
+    }
+
+    private async initialiseThread(): Promise<void> {
+        let bundledRelationship = this.getRootEventBundledRelationship();
+        if (Thread.hasServerSideSupport && !bundledRelationship) {
+            await this.fetchRootEvent();
+            bundledRelationship = this.getRootEventBundledRelationship();
+        }

        if (Thread.hasServerSideSupport && bundledRelationship) {
            this.replyCount = bundledRelationship.count;
@@ -233,6 +277,8 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {

            this.fetchEditsWhereNeeded(event);
        }
+
+        this.emit(ThreadEvent.Update, this);
    }

    // XXX: Workaround for https://github.com/matrix-org/matrix-spec-proposals/pull/2676/files#r827240084
@@ -250,24 +296,10 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
        }));
    }

-    public async fetchInitialEvents(): Promise<{
-        originalEvent: MatrixEvent;
-        events: MatrixEvent[];
-        nextBatch?: string;
-        prevBatch?: string;
-    } | null> {
-        if (!Thread.hasServerSideSupport) {
-            this.initialEventsFetched = true;
-            return null;
-        }
-
-        try {
-            const response = await this.fetchEvents();
-            this.initialEventsFetched = true;
-            return response;
-        } catch (e) {
-            return null;
-        }
+    public async fetchInitialEvents(): Promise<void> {
+        if (this.initialEventsFetched) return;
+        await this.fetchEvents();
+        this.initialEventsFetched = true;
    }

    private setEventMetadata(event: MatrixEvent): void {
@@ -316,7 +348,7 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
     * A getter for the last event added to the thread
     */
    public get replyToEvent(): MatrixEvent {
-        return this.lastEvent;
+        return this.lastEvent ?? this.lastReply();
    }

    public get events(): MatrixEvent[] {
@@ -335,7 +367,7 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
        return this.timelineSet.getLiveTimeline();
    }

-    public async fetchEvents(opts: IRelationsRequestOpts = { limit: 20 }): Promise<{
+    public async fetchEvents(opts: IRelationsRequestOpts = { limit: 20, direction: Direction.Backward }): Promise<{
        originalEvent: MatrixEvent;
        events: MatrixEvent[];
        nextBatch?: string;
@@ -367,7 +399,7 @@ export class Thread extends TypedEventEmitter<EmittedEvents, EventHandlerMap> {
            return this.client.decryptEventIfNeeded(event);
        }));

-        const prependEvents = !opts.direction || opts.direction === Direction.Backward;
+        const prependEvents = (opts.direction ?? Direction.Backward) === Direction.Backward;

        this.timelineSet.addEventsToTimeline(
            events,
@@ -17,11 +17,12 @@ limitations under the License.
 import { EventType } from "../@types/event";
 import { Room } from "../models/room";
 import { User } from "../models/user";
-import { IEvent, MatrixEvent } from "../models/event";
+import { MatrixEvent } from "../models/event";
 import { Filter } from "../filter";
 import { RoomSummary } from "../models/room-summary";
 import { IMinimalEvent, IRooms, ISyncResponse } from "../sync-accumulator";
 import { IStartClientOpts } from "../client";
+import { IStateEventWithRoomId } from "../@types/search";

 export interface ISavedSync {
    nextBatch: string;
@@ -204,9 +205,9 @@ export interface IStore {
     */
    deleteAllData(): Promise<void>;

-    getOutOfBandMembers(roomId: string): Promise<IEvent[] | null>;
+    getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null>;

-    setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void>;
+    setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void>;

    clearOutOfBandMembers(roomId: string): Promise<void>;

@@ -15,7 +15,7 @@ limitations under the License.
 */

 import { ISavedSync } from "./index";
-import { IEvent, IStartClientOpts, ISyncResponse } from "..";
+import { IEvent, IStartClientOpts, IStateEventWithRoomId, ISyncResponse } from "..";

 export interface IIndexedDBBackend {
    connect(): Promise<void>;
@@ -25,8 +25,8 @@ export interface IIndexedDBBackend {
    getSavedSync(): Promise<ISavedSync>;
    getNextBatchToken(): Promise<string>;
    clearDatabase(): Promise<void>;
-    getOutOfBandMembers(roomId: string): Promise<IEvent[] | null>;
-    setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void>;
+    getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null>;
+    setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void>;
    clearOutOfBandMembers(roomId: string): Promise<void>;
    getUserPresenceEvents(): Promise<UserTuple[]>;
    getClientOptions(): Promise<IStartClientOpts>;
@@ -18,7 +18,7 @@ import { IMinimalEvent, ISyncData, ISyncResponse, SyncAccumulator } from "../syn
 import * as utils from "../utils";
 import * as IndexedDBHelpers from "../indexeddb-helpers";
 import { logger } from '../logger';
-import { IEvent, IStartClientOpts } from "..";
+import { IStartClientOpts, IStateEventWithRoomId } from "..";
 import { ISavedSync } from "./index";
 import { IIndexedDBBackend, UserTuple } from "./indexeddb-backend";

@@ -229,15 +229,15 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
     * @returns {Promise<event[]>} the events, potentially an empty array if OOB loading didn't yield any new members
     * @returns {null} in case the members for this room haven't been stored yet
     */
-    public getOutOfBandMembers(roomId: string): Promise<IEvent[] | null> {
-        return new Promise<IEvent[] | null>((resolve, reject) => {
+    public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
+        return new Promise<IStateEventWithRoomId[] | null>((resolve, reject) => {
            const tx = this.db.transaction(["oob_membership_events"], "readonly");
            const store = tx.objectStore("oob_membership_events");
            const roomIndex = store.index("room");
            const range = IDBKeyRange.only(roomId);
            const request = roomIndex.openCursor(range);

-            const membershipEvents: IEvent[] = [];
+            const membershipEvents: IStateEventWithRoomId[] = [];
            // did we encounter the oob_written marker object
            // amongst the results? That means OOB member
            // loading already happened for this room
@@ -278,7 +278,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
     * @param {string} roomId
     * @param {event[]} membershipEvents the membership events to store
     */
-    public async setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void> {
+    public async setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
        logger.log(`LL: backend about to store ${membershipEvents.length}` +
            ` members for ${roomId}`);
        const tx = this.db.transaction(["oob_membership_events"], "readwrite");
@@ -530,9 +530,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
            const txn = this.db.transaction(["client_options"], "readonly");
            const store = txn.objectStore("client_options");
            return selectQuery(store, undefined, (cursor) => {
-                if (cursor.value && cursor.value && cursor.value.options) {
-                    return cursor.value.options;
-                }
+                return cursor.value?.options;
            }).then((results) => results[0]);
        });
    }
@@ -18,7 +18,7 @@ import { logger } from "../logger";
 import { defer, IDeferred } from "../utils";
 import { ISavedSync } from "./index";
 import { IStartClientOpts } from "../client";
-import { IEvent, ISyncResponse } from "..";
+import { IStateEventWithRoomId, ISyncResponse } from "..";
 import { IIndexedDBBackend, UserTuple } from "./indexeddb-backend";

 export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
@@ -97,7 +97,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
     * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
     * @returns {null} in case the members for this room haven't been stored yet
     */
-    public getOutOfBandMembers(roomId: string): Promise<IEvent[] | null> {
+    public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
        return this.doCmd('getOutOfBandMembers', [roomId]);
    }

@@ -109,7 +109,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
     * @param {event[]} membershipEvents the membership events to store
     * @returns {Promise} when all members have been stored
     */
-    public setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void> {
+    public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
        return this.doCmd('setOutOfBandMembers', [roomId, membershipEvents]);
    }

@@ -26,6 +26,7 @@ import { ISavedSync } from "./index";
 import { IIndexedDBBackend } from "./indexeddb-backend";
 import { ISyncResponse } from "../sync-accumulator";
 import { TypedEventEmitter } from "../models/typed-event-emitter";
+import { IStateEventWithRoomId } from "../@types/search";

 /**
 * This is an internal module. See {@link IndexedDBStore} for the public class.
@@ -242,7 +243,7 @@ export class IndexedDBStore extends MemoryStore {
     * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
     * @returns {null} in case the members for this room haven't been stored yet
     */
-    public getOutOfBandMembers = this.degradable((roomId: string): Promise<IEvent[]> => {
+    public getOutOfBandMembers = this.degradable((roomId: string): Promise<IStateEventWithRoomId[]> => {
        return this.backend.getOutOfBandMembers(roomId);
    }, "getOutOfBandMembers");

@@ -254,10 +255,13 @@ export class IndexedDBStore extends MemoryStore {
     * @param {event[]} membershipEvents the membership events to store
     * @returns {Promise} when all members have been stored
     */
-    public setOutOfBandMembers = this.degradable((roomId: string, membershipEvents: IEvent[]): Promise<void> => {
-        super.setOutOfBandMembers(roomId, membershipEvents);
-        return this.backend.setOutOfBandMembers(roomId, membershipEvents);
-    }, "setOutOfBandMembers");
+    public setOutOfBandMembers = this.degradable(
+        (roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> => {
+            super.setOutOfBandMembers(roomId, membershipEvents);
+            return this.backend.setOutOfBandMembers(roomId, membershipEvents);
+        },
+        "setOutOfBandMembers",
+    );

    public clearOutOfBandMembers = this.degradable((roomId: string) => {
        super.clearOutOfBandMembers(roomId);
@@ -22,13 +22,14 @@ limitations under the License.
 import { EventType } from "../@types/event";
 import { Room } from "../models/room";
 import { User } from "../models/user";
-import { IEvent, MatrixEvent } from "../models/event";
+import { MatrixEvent } from "../models/event";
 import { RoomState, RoomStateEvent } from "../models/room-state";
 import { RoomMember } from "../models/room-member";
 import { Filter } from "../filter";
 import { ISavedSync, IStore } from "./index";
 import { RoomSummary } from "../models/room-summary";
 import { ISyncResponse } from "../sync-accumulator";
+import { IStateEventWithRoomId } from "../@types/search";

 function isValidFilterId(filterId: string): boolean {
    const isValidStr = typeof filterId === "string" &&
@@ -60,7 +61,7 @@ export class MemoryStore implements IStore {
    private filters: Record<string, Record<string, Filter>> = {};
    public accountData: Record<string, MatrixEvent> = {}; // type : content
    private readonly localStorage: Storage;
-    private oobMembers: Record<string, IEvent[]> = {}; // roomId: [member events]
+    private oobMembers: Record<string, IStateEventWithRoomId[]> = {}; // roomId: [member events]
    private clientOptions = {};

    constructor(opts: IOpts = {}) {
@@ -389,7 +390,7 @@ export class MemoryStore implements IStore {
     * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
     * @returns {null} in case the members for this room haven't been stored yet
     */
-    public getOutOfBandMembers(roomId: string): Promise<IEvent[] | null> {
+    public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
        return Promise.resolve(this.oobMembers[roomId] || null);
    }

@@ -401,7 +402,7 @@ export class MemoryStore implements IStore {
     * @param {event[]} membershipEvents the membership events to store
     * @returns {Promise} when all members have been stored
     */
-    public setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void> {
+    public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
        this.oobMembers[roomId] = membershipEvents;
        return Promise.resolve();
    }
@@ -78,7 +78,7 @@ WebStorageSessionStore.prototype = {
        const devices = {};
        for (let i = 0; i < this.store.length; ++i) {
            const key = this.store.key(i);
-            const userId = key.substr(prefix.length);
+            const userId = key.slice(prefix.length);
            if (key.startsWith(prefix)) devices[userId] = getJsonItem(this.store, key);
        }
        return devices;
@@ -125,7 +125,7 @@ WebStorageSessionStore.prototype = {
        const deviceKeys = getKeysWithPrefix(this.store, keyEndToEndSessions(''));
        const results = {};
        for (const k of deviceKeys) {
-            const unprefixedKey = k.substr(keyEndToEndSessions('').length);
+            const unprefixedKey = k.slice(keyEndToEndSessions('').length);
            results[unprefixedKey] = getJsonItem(this.store, k);
        }
        return results;
@@ -158,8 +158,8 @@ WebStorageSessionStore.prototype = {
            // (hence 43 characters long).

            result.push({
-                senderKey: key.substr(prefix.length, 43),
-                sessionId: key.substr(prefix.length + 44),
+                senderKey: key.slice(prefix.length, prefix.length + 43),
+                sessionId: key.slice(prefix.length + 44),
            });
        }
        return result;
@@ -182,7 +182,7 @@ WebStorageSessionStore.prototype = {
        const roomKeys = getKeysWithPrefix(this.store, keyEndToEndRoom(''));
        const results = {};
        for (const k of roomKeys) {
-            const unprefixedKey = k.substr(keyEndToEndRoom('').length);
+            const unprefixedKey = k.slice(keyEndToEndRoom('').length);
            results[unprefixedKey] = getJsonItem(this.store, k);
        }
        return results;
@@ -22,11 +22,12 @@ limitations under the License.
 import { EventType } from "../@types/event";
 import { Room } from "../models/room";
 import { User } from "../models/user";
-import { IEvent, MatrixEvent } from "../models/event";
+import { MatrixEvent } from "../models/event";
 import { Filter } from "../filter";
 import { ISavedSync, IStore } from "./index";
 import { RoomSummary } from "../models/room-summary";
 import { ISyncResponse } from "../sync-accumulator";
+import { IStateEventWithRoomId } from "../@types/search";

 /**
 * Construct a stub store. This does no-ops on most store methods.
@@ -242,11 +243,11 @@ export class StubStore implements IStore {
        return Promise.resolve();
    }

-    public getOutOfBandMembers(): Promise<IEvent[]> {
+    public getOutOfBandMembers(): Promise<IStateEventWithRoomId[]> {
        return Promise.resolve(null);
    }

-    public setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void> {
+    public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
        return Promise.resolve();
    }

@@ -1170,7 +1170,6 @@ export class SyncApi {
            stateEvents.forEach(function(e) {
                client.emit(ClientEvent.Event, e);
            });
-            room.updateMyMembership("invite");
        });

        // Handle joins
@@ -1317,8 +1316,6 @@ export class SyncApi {
                client.emit(ClientEvent.Event, e);
            });

-            room.updateMyMembership("join");
-
            // Decrypt only the last message in all rooms to make sure we can generate a preview
            // And decrypt all events after the recorded read receipt to ensure an accurate
            // notification count
@@ -1352,8 +1349,6 @@ export class SyncApi {
            accountDataEvents.forEach(function(e) {
                client.emit(ClientEvent.Event, e);
            });
-
-            room.updateMyMembership("leave");
        });

        // update the notification timeline, if appropriate.
@@ -1641,6 +1636,7 @@ export class SyncApi {
        // This also needs to be done before running push rules on the events as they need
        // to be decorated with sender etc.
        room.addLiveEvents(timelineEventList || [], null, fromCache);
+        this.client.processBeaconEvents(room, timelineEventList);
    }

    /**
@@ -24,6 +24,8 @@ import unhomoglyph from "unhomoglyph";
 import promiseRetry from "p-retry";

 import type NodeCrypto from "crypto";
+import { MatrixEvent } from ".";
+import { M_TIMESTAMP } from "./@types/location";

 /**
 * Encode a dictionary of query parameters.
@@ -425,7 +427,7 @@ export function globToRegexp(glob: string, extended?: any): string {

 export function ensureNoTrailingSlash(url: string): string {
    if (url && url.endsWith("/")) {
-        return url.substr(0, url.length - 1);
+        return url.slice(0, -1);
    } else {
        return url;
    }
@@ -462,7 +464,7 @@ export function defer<T = void>(): IDeferred<T> {
 }

 export async function promiseMapSeries<T>(
-    promises: T[],
+    promises: Array<T | Promise<T>>,
    fn: (t: T) => void,
 ): Promise<void> {
    for (const o of promises) {
@@ -708,3 +710,15 @@ export function recursivelyAssign(target: Object, source: Object, ignoreNullish
    }
    return target;
 }
+
+function getContentTimestampWithFallback(event: MatrixEvent): number {
+    return M_TIMESTAMP.findIn<number>(event.getContent()) ?? -1;
+}
+
+/**
+ * Sort events by their content m.ts property
+ * Latest timestamp first
+ */
+export function sortEventsByLatestContentTimestamp(left: MatrixEvent, right: MatrixEvent): number {
+    return getContentTimestampWithFallback(right) - getContentTimestampWithFallback(left);
+}
Author	SHA1	Message	Date
RiotRobot	e29ee105aa	v17.2.0	2022-05-10 14:46:15 +01:00
RiotRobot	454eb7e627	Prepare changelog for v17.2.0	2022-05-10 14:46:15 +01:00
RiotRobot	70c6a4b567	v17.2.0-rc.1	2022-05-03 15:20:39 +01:00
RiotRobot	5cd615c495	Prepare changelog for v17.2.0-rc.1	2022-05-03 15:20:38 +01:00
Michael Telatynski	88f5ea675d	Tweak sonarqube run (#2339 )	2022-05-03 14:46:36 +01:00
Michael Telatynski	ac5fee0a69	Fix race conditions around threads (#2331 )	2022-05-03 14:25:17 +01:00
Michael Telatynski	274d6a9597	Add CI to require labels on PRs for better changelog management (#2337 )	2022-05-03 10:34:55 +01:00
Michael Telatynski	d190cdc307	Switch coverage to SonarQube (#2334 )	2022-05-02 08:32:53 +00:00
Michael Telatynski	b896111269	Apply corrections identified by SonarQube (#2336 ) * Apply corrections identified by SonarQube * Apply corrections identified by SonarQube * Make type more flexible	2022-05-02 03:23:17 +01:00
Aaron Raimist	6137afeb28	Mark room versions 7, 8, and 9 as safe (#2318 ) * Mark room versions 7, 8, and 9 as safe Workaround for https://github.com/vector-im/element-web/issues/20166 https://github.com/vector-im/element-web/issues/11820 * Update KNOWN_SAFE_ROOM_VERSION to room version 9	2022-05-01 19:10:09 -06:00
Michael Telatynski	2ebf33544f	Try SonarCloud (#2330 )	2022-04-29 11:07:35 +01:00
Michael Telatynski	45f1991d4e	Correctly specify minimum Node version (#2324 )	2022-04-29 11:02:05 +01:00
Michael Telatynski	aa283a3c9e	Update CONTRIBUTING.md (#2329 )	2022-04-28 15:48:21 +01:00
Kerry	34ee566d88	Live location sharing: handle encrypted messages in processBeaconEvents (#2327 ) * handle encrypted locations Signed-off-by: Kerry Archibald <kerrya@element.io> * fix processBeaconEvents to handle encrypted events Signed-off-by: Kerry Archibald <kerrya@element.io>	2022-04-28 16:42:37 +02:00
RiotRobot	3649cf46d3	Resetting package fields for development	2022-04-26 11:34:42 +01:00
RiotRobot	8f00eb6771	Merge branch 'master' into develop	2022-04-26 11:34:42 +01:00
Michael Telatynski	01ec51891a	Merge remote-tracking branch 'origin/release-v17.1.0' # Conflicts: # CHANGELOG.md # package.json # src/client.ts # src/models/room.ts # src/models/thread.ts # src/sync.ts	2022-04-26 11:31:20 +01:00
RiotRobot	738876a563	v17.1.0	2022-04-26 11:13:47 +01:00
RiotRobot	2d9b4b3896	Prepare changelog for v17.1.0	2022-04-26 11:13:46 +01:00
Michael Telatynski	ba06e430c4	Ignore m.replace relations on state events, they're invalid (#2306 ) * Ignore m.replace relations on state events, they're invalid * Add tests * Fix test Co-authored-by: Kerry <kerrya@element.io>	2022-04-26 10:02:36 +00:00
Michael Telatynski	ac08e52410	De-duplicate code and fix types (#2319 )	2022-04-25 17:15:35 +01:00
David Baker	1bb82108b7	fix example in readme (#2315 ) Co-authored-by: Matthew Hodgson <matthew@matrix.org>	2022-04-22 12:04:31 +01:00
Michael Telatynski	e133005b44	Don't decrement the length count of a thread when root redacted (#2314 )	2022-04-21 16:02:42 +00:00
Michael Telatynski	c0cb66233a	Prevent attempt to create thread with id "undefined" (#2308 )	2022-04-21 08:01:24 +01:00
Michael Telatynski	d82cdd3b19	Move more stuff from BK to GHA (#2309 )	2022-04-20 18:09:33 +01:00
Michael Telatynski	6a51b02bed	Move more stuff from BK to GHA (#2307 ) * Use consistent indentation in GHA yaml files * Prefer setup-node's dep caching * Tidy up test_coverage job * Move js sdk lint ci to gha * notify react-sdk of develop merges * Name the jobs * test * Update secrets * Fixup	2022-04-20 16:25:58 +01:00
Michael Telatynski	47d2c063fa	Upgrade dependencies (#2304 )	2022-04-20 13:53:39 +02:00
Michael Telatynski	540514c805	Update threads handling for replies-to-thread-responses as per MSC update (#2305 ) * Update threads handling for replies-to-thread-responses as per MSC update * Update tests to match new behaviour	2022-04-19 18:15:06 +02:00
Faye Duxovni	db58a66e19	Add method for checking whether our other devices are cross-signed, even when this device isn't (#2288 )	2022-04-19 15:02:17 +01:00
RiotRobot	91a67bdac3	v17.1.0-rc.1	2022-04-19 14:41:27 +01:00
RiotRobot	48d3fce22d	Prepare changelog for v17.1.0-rc.1	2022-04-19 14:41:26 +01:00
Hugh Nimmo-Smith	9f4598638d	Add MatrixClient.doesServerSupportLogoutDevices() for MSC2457 (#2297 )	2022-04-15 10:27:12 +01:00
CommanderRoot	cde935629d	Replace deprecated String.prototype.substr() (#2298 ) .substr() is deprecated so we replace it with .slice() which works similarily but isn't deprecated Signed-off-by: Tobias Speicher <rootcommander@gmail.com>	2022-04-14 15:23:27 -06:00
Kerry	fbe81ad823	Live location sharing - expose room liveBeaconIds (#2296 ) * updates rooms live beacon ids on destroy Signed-off-by: Kerry Archibald <kerrya@element.io> * expose live beacons ids Signed-off-by: Kerry Archibald <kerrya@element.io> * room state emit all the time on beacon liveness change Signed-off-by: Kerry Archibald <kerrya@element.io> * update comment Signed-off-by: Kerry Archibald <kerrya@element.io>	2022-04-14 15:04:43 +02:00
Michael Telatynski	c3d7a4977a	Stop tracking threads if threads support is disabled (#2295 )	2022-04-13 16:23:15 +01:00
Robin	9aab917836	Fix coverage diffs for PRs that aren't up to date, take 3 (#2294 )	2022-04-12 20:22:14 -04:00
Jonathan de Jong	54661cca95	Change `_unstable_getSharedRooms` to `_unstable_getMutualRooms` (#2271 ) * change shared to mutual * revert name change * use new unstable feature flag * support both unstable endpoints	2022-04-12 17:48:48 -06:00
Michael Telatynski	b58d09aa9a	Prevent duplicated re-emitter setups in event-mapper (#2293 )	2022-04-12 09:42:55 +01:00
RiotRobot	3b33237e51	Resetting package fields for development	2022-04-11 16:31:44 +01:00
RiotRobot	b8ec62e786	Merge master	2022-04-11 16:31:21 +01:00
RiotRobot	59763a84f8	v17.0.0	2022-04-11 16:21:09 +01:00
RiotRobot	1375a4849c	Prepare changelog for v17.0.0	2022-04-11 16:21:09 +01:00
Michael Telatynski	286500e335	Fix issues around echo & redaction handling in threads (#2286 )	2022-04-11 08:58:13 +01:00
Hugh Nimmo-Smith	5937e6a6a8	Support for MSC2457 logout_devices param for setPassword() (#2285 )	2022-04-09 14:07:33 +01:00
Eric Eastwood	c6c22e394b	Ignore `eslint --fix` formatting changes in git blame (#2287 ) * Ignore eslint --fix formatting changes in git blame Docs: https://docs.github.com/en/repositories/working-with-files/using-files/viewing-a-file#ignore-commits-in-the-blame-view * Conform on white-space spelling	2022-04-08 23:52:05 -06:00
Callum Brown	378802a5ab	Stabilise token authenticated registration support (#2181 ) * Stabilise token authenticated registration support Token authenticated registration was added to the Matrix specification in v1.2: https://spec.matrix.org/v1.2/client-server-api/#token-authenticated-registration Signed-off-by: Callum Brown <callum@calcuode.com> * Backwards compatibility with unstable auth type Servers are not yet widely updated with support for the stable version of the registration token UIA type. Clients should check if the authentication type is either `RegistrationToken` or `UnstableRegistrationToken`. Signed-off-by: Callum Brown <callum@calcuode.com>	2022-04-08 22:53:57 -06:00
Kerry	f963feab0f	Live location sharing - Aggregate beacon locations on beacons (#2268 ) * add timestamp sorting util Signed-off-by: Kerry Archibald <kerrya@element.io> * basic wiring Signed-off-by: Kerry Archibald <kerrya@element.io> * quick handle for redacted beacons Signed-off-by: Kerry Archibald <kerrya@element.io> * remove fdescribe Signed-off-by: Kerry Archibald <kerrya@element.io> * test adding locations Signed-off-by: Kerry Archibald <kerrya@element.io> * tidy comments Signed-off-by: Kerry Archibald <kerrya@element.io> * test client Signed-off-by: Kerry Archibald <kerrya@element.io> * fix monitorLiveness for update Signed-off-by: Kerry Archibald <kerrya@element.io> * lint Signed-off-by: Kerry Archibald <kerrya@element.io>	2022-04-08 12:26:05 +01:00
Germain	6d0f4e537e	Fix notification panel not loading (#2283 )	2022-04-08 10:34:01 +01:00
Kerry	781fdf4fdc	Live location sharing - update beacon_info implementation to latest MSC (#2281 ) * remove M_BEACON_INFO_VARIABLE Signed-off-by: Kerry Archibald <kerrya@element.io> * create beacon_info events with non-variable event type Signed-off-by: Kerry Archibald <kerrya@element.io> * remove isBeaconInfoEventType Signed-off-by: Kerry Archibald <kerrya@element.io> * refer to msc3673 instead of msc3489 Signed-off-by: Kerry Archibald <kerrya@element.io> * remove event type suffix Signed-off-by: Kerry Archibald <kerrya@element.io> * update beacon identifier to use state key Signed-off-by: Kerry Archibald <kerrya@element.io> * fix beacon spec Signed-off-by: Kerry Archibald <kerrya@element.io> * fix room-state tests Signed-off-by: Kerry Archibald <kerrya@element.io> * add beacon identifier Signed-off-by: Kerry Archibald <kerrya@element.io> * dont allow update to older beacon event Signed-off-by: Kerry Archibald <kerrya@element.io> * lint Signed-off-by: Kerry Archibald <kerrya@element.io> * unnest beacon_info content Signed-off-by: Kerry Archibald <kerrya@element.io> * lint Signed-off-by: Kerry Archibald <kerrya@element.io> * check redaction event id Signed-off-by: Kerry Archibald <kerrya@element.io>	2022-04-08 10:50:06 +02:00
Michael Telatynski	dde4285cdf	Fix handling of threaded messages around edits & echoes (#2267 )	2022-04-07 13:46:50 +01:00
Robin	3322b47b6d	Make self membership less prone to races (#2277 )	2022-04-06 08:49:09 -04:00