Merge branch 'develop' into toger5/use-relation-based-CallMembership-create-ts

Signed-off-by: Timo K <[email protected]>

Author: toger5

.github/workflows/pull_request.yaml

@@ -49,7 +49,7 @@ jobs:
             pull-requests: write
         steps:
             - name: Check membership
-              if: github.event.pull_request.user.login != 'renovate[bot]'
+              if: github.event.pull_request.user.login != 'renovate[bot]' && github.event.pull_request.user.login != 'dependabot[bot]'
               uses: tspascoal/get-user-teams-membership@57e9f42acd78f4d0f496b3be4368fc5f62696662 # v3
               id: teams
               with:

CHANGELOG.md

@@ -1,3 +1,15 @@
+Changes in [38.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v38.4.0) (2025-10-07)
+==================================================================================================
+## ✨ Features
+
+* Add call intent to RTC call notifications ([#5010](https://github.com/matrix-org/matrix-js-sdk/pull/5010)). Contributed by @Half-Shot.
+* Implement experimental encrypted state events. ([#4994](https://github.com/matrix-org/matrix-js-sdk/pull/4994)). Contributed by @kaylendog.
+
+## 🐛 Bug Fixes
+
+* Exclude cancelled requests from in-progress lists ([#5016](https://github.com/matrix-org/matrix-js-sdk/pull/5016)). Contributed by @andybalaam.
+
+
 Changes in [38.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v38.3.0) (2025-09-23)
 ==================================================================================================
 ## 🐛 Bug Fixes

knip.ts

@@ -12,10 +12,6 @@ export default {
         "src/utils.ts", // not really an entrypoint but we have deprecated `defer` there
         "scripts/**",
         "spec/**",
-        // XXX: these look entirely unused
-        "src/crypto/aes.ts",
-        "src/crypto/crypto.ts",
-        "src/crypto/recoverykey.ts",
         // XXX: these should be re-exported by one of the supported exports
         "src/matrixrtc/index.ts",
         "src/sliding-sync.ts",

package.json

@@ -1,6 +1,6 @@
 {
     "name": "matrix-js-sdk",
-    "version": "38.3.0",
+    "version": "38.4.0",
     "description": "Matrix Client-Server SDK for Javascript",
     "engines": {
         "node": ">=22.0.0"

spec/integ/crypto/verification.spec.ts

@@ -46,8 +46,8 @@ import {
     type Verifier,
     VerifierEvent,
 } from "../../../src/crypto-api/verification";
-import { escapeRegExp } from "../../../src/utils";
-import { awaitDecryption, emitPromise, getSyncResponse, syncPromise } from "../../test-utils/test-utils";
+import { escapeRegExp, sleep } from "../../../src/utils";
+import { awaitDecryption, emitPromise, getSyncResponse, syncPromise, waitFor } from "../../test-utils/test-utils";
 import { SyncResponder } from "../../test-utils/SyncResponder";
 import {
     BACKUP_DECRYPTION_KEY_BASE64,
@@ -79,11 +79,6 @@ import {
 import { type KeyBackupInfo, CryptoEvent } from "../../../src/crypto-api";
 import { encodeBase64 } from "../../../src/base64";
 
-// The verification flows use javascript timers to set timeouts. We tell jest to use mock timer implementations
-// to ensure that we don't end up with dangling timeouts.
-// But the wasm bindings of matrix-sdk-crypto rely on a working `queueMicrotask`.
-jest.useFakeTimers({ doNotFake: ["queueMicrotask"] });
-
 beforeAll(async () => {
     // we use the libolm primitives in the test, so init the Olm library
     await Olm.init();
@@ -96,6 +91,13 @@ beforeAll(async () => {
     await RustSdkCryptoJs.initAsync();
 }, 10000);
 
+beforeEach(() => {
+    // The verification flows use javascript timers to set timeouts. We tell jest to use mock timer implementations
+    // to ensure that we don't end up with dangling timeouts.
+    // But the wasm bindings of matrix-sdk-crypto rely on a working `queueMicrotask`.
+    jest.useFakeTimers({ doNotFake: ["queueMicrotask"] });
+});
+
 afterEach(() => {
     // reset fake-indexeddb after each test, to make sure we don't leak connections
     // cf https://github.com/dumbmatter/fakeIndexedDB#wipingresetting-the-indexeddb-for-a-fresh-state
@@ -1080,6 +1082,13 @@ describe("verification", () => {
         });
 
         it("ignores old verification requests", async () => {
+            const debug = jest.fn();
+            const info = jest.fn();
+            const warn = jest.fn();
+
+            // @ts-ignore overriding RustCrypto's logger
+            aliceClient.getCrypto()!.logger = { debug, info, warn };
+
             const eventHandler = jest.fn();
             aliceClient.on(CryptoEvent.VerificationRequestReceived, eventHandler);
 
@@ -1094,6 +1103,16 @@ describe("verification", () => {
             const matrixEvent = room.getLiveTimeline().getEvents()[0];
             expect(matrixEvent.getId()).toEqual(verificationRequestEvent.event_id);
 
+            // Wait until the request has been processed. We use a real sleep()
+            // here to make sure any background async tasks are completed.
+            jest.useRealTimers();
+            await waitFor(async () => {
+                expect(info).toHaveBeenCalledWith(
+                    expect.stringMatching(/^Ignoring just-received verification request/),
+                );
+                sleep(100);
+            });
+
             // check that an event has not been raised, and that the request is not found
             expect(eventHandler).not.toHaveBeenCalled();
             expect(

spec/unit/matrix-client.spec.ts

@@ -2366,6 +2366,61 @@ describe("MatrixClient", function () {
         });
     });
 
+    describe("disableVoip option", () => {
+        const baseUrl = "https://alice-server.com";
+        const userId = "@alice:bar";
+        const accessToken = "sometoken";
+
+        beforeEach(() => {
+            mocked(supportsMatrixCall).mockReturnValue(true);
+        });
+
+        afterAll(() => {
+            mocked(supportsMatrixCall).mockReset();
+        });
+
+        it("should not call /voip/turnServer when disableVoip = true", () => {
+            fetchMock.getOnce(`${baseUrl}/_matrix/client/unstable/voip/turnServer`, 200);
+
+            const client = createClient({
+                baseUrl,
+                accessToken,
+                userId,
+                disableVoip: true,
+            });
+
+            // Only check createCall / supportsVoip, avoid startClient
+            expect(client.createCall("!roomId:example.com")).toBeNull();
+            expect(client.supportsVoip?.()).toBe(false);
+        });
+
+        it("should call /voip/turnServer when disableVoip is not set", () => {
+            fetchMock.getOnce(`${baseUrl}/_matrix/client/unstable/voip/turnServer`, {
+                uris: ["turn:turn.example.org"],
+            });
+
+            createClient({
+                baseUrl,
+                accessToken,
+                userId,
+            });
+
+            // The call will trigger the request if VoIP is supported
+            expect(fetchMock.called(`${baseUrl}/_matrix/client/unstable/voip/turnServer`)).toBe(false);
+        });
+
+        it("should return null from createCall when disableVoip = true", () => {
+            const client = createClient({
+                baseUrl,
+                accessToken,
+                userId,
+                disableVoip: true,
+            });
+
+            expect(client.createCall("!roomId:example.com")).toBeNull();
+        });
+    });
+
     describe("support for ignoring invites", () => {
         beforeEach(() => {
             // Mockup `getAccountData`/`setAccountData`.

spec/unit/matrixrtc/CallMembership.spec.ts

@@ -15,8 +15,8 @@ limitations under the License.
 */
 
 import { type MatrixEvent } from "../../../src";
-import { CallMembership, DEFAULT_EXPIRE_DURATION } from "../../../src/matrixrtc/CallMembership";
 import { rtcMembershipTemplate, sessionMembershipTemplate } from "./mocks";
+import { CallMembership, DEFAULT_EXPIRE_DURATION } from "../../../src/matrixrtc/CallMembership";
 
 function makeMockEvent(originTs = 0, content = {}): MatrixEvent {
     return {
@@ -187,12 +187,24 @@ describe("CallMembership", () => {
 
     describe("RtcMembershipData", () => {
         const membershipTemplate = rtcMembershipTemplate;
+
         it("rejects membership with no slot_id", () => {
             expect(() => {
                 new CallMembership(makeMockEvent(0, { ...membershipTemplate, slot_id: undefined }));
             }).toThrow();
         });
 
+        it("rejects membership with invalid slot_id", () => {
+            expect(() => {
+                new CallMembership(makeMockEvent(0, { ...membershipTemplate, slot_id: "invalid_slot_id" }));
+            }).toThrow();
+        });
+        it("accepts membership with valid slot_id", () => {
+            expect(() => {
+                new CallMembership(makeMockEvent(0, { ...membershipTemplate, slot_id: "m.call#" }));
+            }).not.toThrow();
+        });
+
         it("rejects membership with no application", () => {
             expect(() => {
                 new CallMembership(makeMockEvent(0, { ...membershipTemplate, application: undefined }));
@@ -248,18 +260,91 @@ describe("CallMembership", () => {
                 new CallMembership(
                     makeMockEvent(0, {
                         ...membershipTemplate,
-                        member: { id: "test", device_id: "test", user_id: "@test:user.id" },
+                        member: { id: "test", device_id: "test", user_id: "@test-wrong-user:user.id" },
+                    }),
+                );
+            }).toThrow();
+        });
+        it("rejects membership with incorrect sticky_key", () => {
+            expect(() => {
+                new CallMembership(makeMockEvent(0, membershipTemplate));
+            }).not.toThrow();
+            expect(() => {
+                new CallMembership(
+                    makeMockEvent(0, {
+                        ...membershipTemplate,
+                        sticky_key: 1,
+                        msc4354_sticky_key: undefined,
+                    }),
+                );
+            }).toThrow();
+            expect(() => {
+                new CallMembership(
+                    makeMockEvent(0, {
+                        ...membershipTemplate,
+                        sticky_key: "1",
+                        msc4354_sticky_key: undefined,
                     }),
                 );
             }).not.toThrow();
+            expect(() => {
+                new CallMembership(makeMockEvent(0, { ...membershipTemplate, msc4354_sticky_key: undefined }));
+            }).toThrow();
+            expect(() => {
+                new CallMembership(
+                    makeMockEvent(0, {
+                        ...membershipTemplate,
+                        msc4354_sticky_key: 1,
+                        sticky_key: "valid",
+                    }),
+                );
+            }).toThrow();
+            expect(() => {
+                new CallMembership(
+                    makeMockEvent(0, {
+                        ...membershipTemplate,
+                        msc4354_sticky_key: "valid",
+                        sticky_key: "valid",
+                    }),
+                );
+            }).not.toThrow();
+            expect(() => {
+                new CallMembership(
+                    makeMockEvent(0, {
+                        ...membershipTemplate,
+                        msc4354_sticky_key: "valid_but_different",
+                        sticky_key: "valid",
+                    }),
+                );
+            }).toThrow();
         });
 
         it("considers memberships unexpired if local age low enough", () => {
-            // TODO link prev event
+            const now = Date.now();
+            const startEv = makeMockEvent(now - DEFAULT_EXPIRE_DURATION + 100, membershipTemplate);
+            const membershipWithRel = new CallMembership(
+                //update 900 ms later
+                makeMockEvent(now - DEFAULT_EXPIRE_DURATION + 1000, membershipTemplate),
+                startEv,
+            );
+            const membershipWithoutRel = new CallMembership(startEv);
+            expect(membershipWithRel.isExpired()).toEqual(false);
+            expect(membershipWithoutRel.isExpired()).toEqual(false);
+            expect(membershipWithoutRel.createdTs()).toEqual(membershipWithRel.createdTs());
         });
 
         it("considers memberships expired if local age large enough", () => {
-            // TODO link prev event
+            const now = Date.now();
+            const startEv = makeMockEvent(now - DEFAULT_EXPIRE_DURATION - 100, membershipTemplate);
+            const membershipWithRel = new CallMembership(
+                //update 1100 ms later (so the update is still after expiry)
+                makeMockEvent(now - DEFAULT_EXPIRE_DURATION + 1000, membershipTemplate),
+                startEv,
+            );
+            const membershipWithoutRel = new CallMembership(startEv);
+            expect(membershipWithRel.isExpired()).toEqual(true);
+            expect(membershipWithoutRel.isExpired()).toEqual(true);
+            expect(membershipWithoutRel.createdTs()).toEqual(membershipWithRel.createdTs());
         });
 
         describe("getTransport", () => {
@@ -279,6 +364,7 @@ describe("CallMembership", () => {
                 expect(membership.getTransport(oldestMembership)).toStrictEqual({ type: "livekit" });
             });
         });
+
         describe("correct values from computed fields", () => {
             const membership = new CallMembership(makeMockEvent(0, membershipTemplate));
             it("returns correct sender", () => {

spec/unit/matrixrtc/MatrixRTCSession.spec.ts

@@ -232,15 +232,16 @@ describe("MatrixRTCSession", () => {
             };
 
             const mockRoom = makeMockRoom([testMembership]);
+            const now = Date.now();
             mockRoom.findEventById = jest
                 .fn()
                 .mockImplementation((id) =>
                     id === "id"
-                        ? new MatrixEvent({ content: { ...rtcMembershipTemplate }, origin_server_ts: 100 })
+                        ? new MatrixEvent({ content: { ...rtcMembershipTemplate }, origin_server_ts: now + 100 })
                         : undefined,
                 );
             sess = await MatrixRTCSession.sessionForSlot(client, mockRoom, callSession);
-            expect(sess.memberships[0].createdTs()).toBe(100);
+            expect(sess.memberships[0].createdTs()).toBe(now + 100);
         });
         it("fetches related events if needed from cs api", async () => {
             const testMembership = {
@@ -251,12 +252,14 @@ describe("MatrixRTCSession", () => {
             };
 
             const mockRoom = makeMockRoom([testMembership]);
+            const now = Date.now();
+
             mockRoom.findEventById = jest.fn().mockReturnValue(undefined);
             client.fetchRoomEvent = jest
                 .fn()
-                .mockResolvedValue({ content: { ...rtcMembershipTemplate }, origin_server_ts: 100 });
+                .mockResolvedValue({ content: { ...rtcMembershipTemplate }, origin_server_ts: now + 100 });
             sess = await MatrixRTCSession.sessionForSlot(client, mockRoom, callSession);
-            expect(sess.memberships[0].createdTs()).toBe(100);
+            expect(sess.memberships[0].createdTs()).toBe(now + 100);
         });
     });
 
@@ -322,9 +325,8 @@ describe("MatrixRTCSession", () => {
                 type: "livekit",
                 focus_selection: "oldest_membership",
             });
-            expect(sess.resolveActiveFocus(sess.memberships.find((m) => m.deviceId === "old"))).toBe(
-                firstPreferredFocus,
-            );
+            const oldest = sess.memberships.find((m) => m.deviceId === "old");
+            expect(oldest?.getTransport(sess.getOldestMembership()!)).toBe(firstPreferredFocus);
             jest.useRealTimers();
         });
         it("does not provide focus if the selection method is unknown", async () => {
@@ -344,7 +346,7 @@ describe("MatrixRTCSession", () => {
                 type: "livekit",
                 focus_selection: "unknown",
             });
-            expect(sess.resolveActiveFocus(sess.memberships.find((m) => m.deviceId === "old"))).toBe(undefined);
+            expect(sess.memberships.length).toBe(0);
         });
     });
 

spec/unit/matrixrtc/MembershipManager.spec.ts

@@ -166,7 +166,7 @@ describe("MembershipManager", () => {
                     room.roomId,
                     "org.matrix.msc4143.rtc.member",
                     {
-                        application: { type: "m.call", id: "" },
+                        application: { type: "m.call" },
                         member: {
                             user_id: "@alice:example.org",
                             id: "_@alice:example.org_AAAAAAA_m.call",

spec/unit/matrixrtc/mocks.ts

@@ -49,12 +49,12 @@ export const sessionMembershipTemplate: SessionMembershipData & { user_id: strin
 };
 
 export const rtcMembershipTemplate: RtcMembershipData = {
-    "slot_id": "m.call#",
-    "application": { "type": "m.call", "m.call.id": "", "m.call.intent": "voice" },
-    "member": { user_id: "@alice:example.org", device_id: "AAAAAAA", id: "xyzHASHxyz" },
-    "rtc_transports": [{ type: "livekit" }],
-    "m.call.intent": "voice",
-    "versions": [],
+    slot_id: "m.call#",
+    application: { "type": "m.call", "m.call.id": "", "m.call.intent": "voice" },
+    member: { user_id: "@alice:example.org", device_id: "AAAAAAA", id: "xyzHASHxyz" },
+    rtc_transports: [{ type: "livekit" }],
+    msc4354_sticky_key: "my_sticky_key",
+    versions: [],
 };
 
 export type MockClient = Pick<