@wireapp/core 46.46.6-beta.14.f6fd03fe6 → 46.46.6

package/lib/conversation/ConversationService/ConversationService.test.js

@@ -45,10 +45,13 @@ const client_1 = require("@wireapp/api-client/lib/client");
 const conversation_1 = require("@wireapp/api-client/lib/conversation");
 const event_1 = require("@wireapp/api-client/lib/event");
 const http_1 = require("@wireapp/api-client/lib/http");
+const team_1 = require("@wireapp/api-client/lib/team");
 const http_status_codes_1 = require("http-status-codes");
 const api_client_1 = require("@wireapp/api-client");
+const core_crypto_1 = require("@wireapp/core-crypto");
 const __1 = require("..");
 const CoreCryptoMLSError_1 = require("../../messagingProtocols/mls/MLSService/CoreCryptoMLSError");
+const MLSService_1 = require("../../messagingProtocols/mls/MLSService/MLSService");
 const MessagingProtocols = __importStar(require("../../messagingProtocols/proteus"));
 const CoreDB_1 = require("../../storage/CoreDB");
 const PayloadHelper = __importStar(require("../../test/PayloadHelper"));
@@ -86,9 +89,14 @@ const mockedProteusService = {
     encryptGenericMessage: () => Promise.resolve(),
     sendProteusMessage: () => Promise.resolve({ sentAt: new Date() }),
 };
+const apiClients = [];
 describe('ConversationService', () => {
+    afterAll(() => {
+        apiClients.forEach(client => client.disconnect());
+    });
     async function buildConversationService() {
         const client = new api_client_1.APIClient({ urls: api_client_1.APIClient.BACKEND.STAGING });
+        apiClients.push(client);
         jest.spyOn(client.api.conversation, 'postMlsMessage').mockReturnValue(Promise.resolve({
             events: [],
             time: new Date().toISOString(),
@@ -106,13 +114,14 @@ describe('ConversationService', () => {
         }));
         jest
             .spyOn(client.api.user, 'getUserSupportedProtocols')
-            .mockReturnValue(Promise.resolve([conversation_1.ConversationProtocol.MLS, conversation_1.ConversationProtocol.PROTEUS]));
+            .mockReturnValue(Promise.resolve([team_1.CONVERSATION_PROTOCOL.MLS, team_1.CONVERSATION_PROTOCOL.PROTEUS]));
         client.context = {
             clientType: client_1.ClientType.NONE,
             userId: PayloadHelper.getUUID(),
             clientId: PayloadHelper.getUUID(),
         };
         const mockedMLSService = {
+            on: jest.fn(),
             encryptMessage: () => { },
             commitPendingProposals: () => Promise.resolve(),
             getEpoch: () => Promise.resolve(),
@@ -124,8 +133,10 @@ describe('ConversationService', () => {
             conversationExists: jest.fn(),
             isConversationEstablished: jest.fn(),
             tryEstablishingMLSGroup: jest.fn(),
+            getClientIdsInGroup: jest.fn(),
             getKeyPackagesPayload: jest.fn(),
             addUsersToExistingConversation: jest.fn(),
+            removeClientsFromConversation: jest.fn(),
             resetKeyMaterialRenewal: jest.fn(),
             handleMLSWelcomeMessageEvent: jest.fn(),
         };
@@ -134,7 +145,7 @@ describe('ConversationService', () => {
         const mockedSubconversationService = {
             joinConferenceSubconversation: jest.fn(),
         };
-        const conversationService = new __1.ConversationService(client, mockedProteusService, mockedDb, groupIdFromConversationId, mockedSubconversationService, mockedMLSService);
+        const conversationService = new __1.ConversationService(client, mockedProteusService, mockedDb, groupIdFromConversationId, mockedSubconversationService, () => Promise.resolve(true), mockedMLSService);
         jest.spyOn(conversationService, 'joinByExternalCommit');
         jest.spyOn(conversationService, 'emit');
         return [
@@ -157,7 +168,7 @@ describe('ConversationService', () => {
                 const sentTime = new Date().toISOString();
                 mockedProteusService.sendMessage = jest.fn().mockResolvedValue({ sentAt: sentTime });
                 const promise = conversationService.send({
-                    protocol: conversation_1.ConversationProtocol.PROTEUS,
+                    protocol: team_1.CONVERSATION_PROTOCOL.PROTEUS,
                     conversationId: { id: 'conv1', domain: '' },
                     payload: message,
                 });
@@ -166,6 +177,80 @@ describe('ConversationService', () => {
             });
         });
     });
+    describe('removeUsersFromMLSConversation', () => {
+        it('recovers and retries when stale-message occurs during remove users commit upload', async () => {
+            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
+            const mockGroupId = 'groupId-stale-remove';
+            const mockConversationId = { id: PayloadHelper.getUUID(), domain: 'staging.zinfra.io' };
+            const qualifiedUserIds = [
+                { id: 'test-id-1', domain: 'test-domain' },
+                { id: 'test-id-2', domain: 'test-domain' },
+            ];
+            const staleMessageError = {
+                type: core_crypto_1.ErrorType.Mls,
+                context: {
+                    type: core_crypto_1.MlsErrorType.MessageRejected,
+                    context: {
+                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }),
+                    },
+                },
+            };
+            // First removal attempt fails with stale, second succeeds
+            jest
+                .spyOn(mlsService, 'removeClientsFromConversation')
+                .mockRejectedValueOnce(staleMessageError)
+                .mockResolvedValueOnce(undefined);
+            const remoteEpoch = 6;
+            const localEpoch = 5;
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
+            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
+            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValue({
+                qualified_id: mockConversationId,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                epoch: remoteEpoch,
+                group_id: mockGroupId,
+            });
+            await conversationService.removeUsersFromMLSConversation({
+                groupId: mockGroupId,
+                conversationId: mockConversationId,
+                qualifiedUserIds,
+            });
+            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(mockConversationId);
+            expect(mlsService.removeClientsFromConversation).toHaveBeenCalledTimes(2);
+            expect(mlsService.resetKeyMaterialRenewal).toHaveBeenCalledWith(mockGroupId);
+        });
+    });
+    describe('joinByExternalCommit', () => {
+        it('retries join when stale-message occurs during external commit join', async () => {
+            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
+            const conversationId = { id: 'conv-join-stale', domain: 'staging.zinfra.io' };
+            const staleMessageError = {
+                type: core_crypto_1.ErrorType.Mls,
+                context: {
+                    type: core_crypto_1.MlsErrorType.MessageRejected,
+                    context: {
+                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }),
+                    },
+                },
+            };
+            jest
+                .spyOn(mlsService, 'joinByExternalCommit')
+                .mockRejectedValueOnce(staleMessageError)
+                .mockResolvedValueOnce(undefined);
+            const remoteEpoch = 10;
+            const localEpoch = 9;
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
+            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
+            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
+                qualified_id: conversationId,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                epoch: remoteEpoch,
+                group_id: 'gid-join-stale',
+            });
+            await conversationService.joinByExternalCommit(conversationId);
+            expect(mlsService.joinByExternalCommit).toHaveBeenCalledTimes(2);
+        });
+    });
     describe('"send MLS"', () => {
         const groupId = PayloadHelper.getUUID();
         const messages = [
@@ -181,7 +266,7 @@ describe('ConversationService', () => {
             it(`calls callbacks when sending '${type}' message is starting and successful`, async () => {
                 const [conversationService] = await buildConversationService();
                 const promise = conversationService.send({
-                    protocol: conversation_1.ConversationProtocol.MLS,
+                    protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                     groupId,
                     payload: message,
                     conversationId: { id: '', domain: '' },
@@ -190,26 +275,62 @@ describe('ConversationService', () => {
                 expect(result.state).toBe(__1.MessageSendingState.OUTGOING_SENT);
             });
         });
-        it('rejoins a MLS group when failed encrypting MLS message', async () => {
+        it('rejoins a MLS group when stale-message error occurs during commit bundle upload', async () => {
             const [conversationService, { apiClient, mlsService }] = await buildConversationService();
             const mockGroupId = 'AAEAAH87aajaQ011i+rNLmwpy0sAZGl5YS53aXJlamxpbms=';
             const mockConversationId = { id: 'mockConversationId', domain: 'staging.zinfra.io' };
             const mockedMessage = MessageBuilder.buildTextMessage({ text: 'test' });
+            const staleMessageError = new conversation_1.MLSStaleMessageError('', http_1.BackendErrorLabel.MLS_STALE_MESSAGE, http_status_codes_1.StatusCodes.CONFLICT);
+            // First attempt to upload commit bundle fails with stale-message, second attempt succeeds
             jest
-                .spyOn(apiClient.api.conversation, 'postMlsMessage')
-                .mockRejectedValueOnce(new http_1.BackendError('', http_1.BackendErrorLabel.MLS_STALE_MESSAGE, http_status_codes_1.StatusCodes.CONFLICT));
+                .spyOn(mlsService, 'commitPendingProposals')
+                .mockRejectedValueOnce(staleMessageError)
+                .mockResolvedValueOnce(undefined);
+            const remoteEpoch = 5;
+            const localEpoch = 4;
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
+            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
+            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
+                qualified_id: mockConversationId,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                epoch: remoteEpoch,
+                group_id: mockGroupId,
+            });
+            await conversationService.send({
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                groupId: mockGroupId,
+                payload: mockedMessage,
+                conversationId: mockConversationId,
+            });
+            // Recovery via external commit should have been triggered
+            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(mockConversationId);
+            expect(conversationService.emit).toHaveBeenCalledWith('MLSConversationRecovered', {
+                conversationId: mockConversationId,
+            });
+            // Because the failure happened before posting the message, postMlsMessage should be called only once (after recovery)
+            expect(apiClient.api.conversation.postMlsMessage).toHaveBeenCalledTimes(1);
+            // commitPendingProposals is called twice: first fails, second succeeds
+            expect(mlsService.commitPendingProposals).toHaveBeenCalledTimes(2);
+        });
+        it('rejoins a MLS group when failed encrypting MLS message', async () => {
+            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
+            const mockGroupId = 'AAEAAH87aajaQ011i+rNLmwpy0sAZGl5YS53aXJlamxpbms=';
+            const mockConversationId = { id: 'mockConversationId', domain: 'staging.zinfra.io' };
+            const mockedMessage = MessageBuilder.buildTextMessage({ text: 'test' });
+            const staleMessageError = new conversation_1.MLSStaleMessageError('', http_1.BackendErrorLabel.MLS_STALE_MESSAGE, http_status_codes_1.StatusCodes.CONFLICT);
+            jest.spyOn(apiClient.api.conversation, 'postMlsMessage').mockRejectedValueOnce(staleMessageError);
             const remoteEpoch = 5;
             const localEpoch = 4;
             jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
             jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
             jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             await conversationService.send({
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 groupId: mockGroupId,
                 payload: mockedMessage,
                 conversationId: mockConversationId,
@@ -220,6 +341,34 @@ describe('ConversationService', () => {
             });
             expect(apiClient.api.conversation.postMlsMessage).toHaveBeenCalledTimes(2);
         });
+        it('adds missing users to MLS group and retries when group is out of sync during send', async () => {
+            const [conversationService, { apiClient }] = await buildConversationService();
+            const mockGroupId = 'AAEAAH87aajaQ011i+rNLmwpy0sAZGl5YS53aXJlamxpbms=';
+            const mockConversationId = { id: 'mockConversationId', domain: 'staging.zinfra.io' };
+            const mockedMessage = MessageBuilder.buildTextMessage({ text: 'test' });
+            const missingUsers = [
+                { id: 'user-1', domain: 'staging.zinfra.io' },
+                { id: 'user-2', domain: 'staging.zinfra.io' },
+            ];
+            const outOfSyncError = new conversation_1.MLSGroupOutOfSyncError(http_status_codes_1.StatusCodes.CONFLICT, missingUsers, http_1.BackendErrorLabel.MLS_GROUP_OUT_OF_SYNC);
+            // First send fails with out-of-sync, second succeeds via default mock
+            jest.spyOn(apiClient.api.conversation, 'postMlsMessage').mockRejectedValueOnce(outOfSyncError);
+            const addUsersSpy = jest
+                .spyOn(conversationService, 'performAddUsersToMLSConversationAPI')
+                .mockResolvedValueOnce({ conversation: { members: { others: [] } } });
+            await conversationService.send({
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                groupId: mockGroupId,
+                payload: mockedMessage,
+                conversationId: mockConversationId,
+            });
+            expect(addUsersSpy).toHaveBeenCalledWith({
+                groupId: mockGroupId,
+                conversationId: mockConversationId,
+                qualifiedUsers: missingUsers,
+            });
+            expect(apiClient.api.conversation.postMlsMessage).toHaveBeenCalledTimes(2);
+        });
     });
     describe('handleConversationsEpochMismatch', () => {
         beforeEach(() => {
@@ -229,7 +378,7 @@ describe('ConversationService', () => {
             return {
                 group_id: 'group-id',
                 qualified_id: { id: conversationId || 'conversation-id', domain: 'staging.zinfra.io' },
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch,
             };
         };
@@ -279,7 +428,7 @@ describe('ConversationService', () => {
             const remoteEpoch = 1;
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
@@ -298,19 +447,19 @@ describe('ConversationService', () => {
             const updatedEpoch = 2;
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             // The 2nd request we make after joining the conversation with external commit
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: updatedEpoch,
                 group_id: mockGroupId,
             });
             jest.spyOn(mlsService, 'isConversationEstablished').mockResolvedValueOnce(false);
-            jest.spyOn(mlsService, 'joinByExternalCommit').mockResolvedValueOnce({ events: [], time: '' });
+            jest.spyOn(mlsService, 'joinByExternalCommit');
             const establishedConversation = await conversationService.establishMLS1to1Conversation(mockGroupId, selfUser, otherUserId);
             expect(mlsService.registerConversation).not.toHaveBeenCalled();
             expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(mockConversationId);
@@ -326,14 +475,14 @@ describe('ConversationService', () => {
             const updatedEpoch = 1;
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             // The 2nd request we make after successfully registering a group
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: updatedEpoch,
                 group_id: mockGroupId,
             });
@@ -355,21 +504,21 @@ describe('ConversationService', () => {
             const updatedEpoch = 1;
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             // The 2nd request we make when retrying to register the conversation
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             // The 3rd request we make after successfully registering a group
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: updatedEpoch,
                 group_id: mockGroupId,
             });
@@ -398,7 +547,7 @@ describe('ConversationService', () => {
             jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
             jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
                 qualified_id: conversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
@@ -432,19 +581,46 @@ describe('ConversationService', () => {
             expect(subconversationService.joinConferenceSubconversation).toHaveBeenCalledWith(conversationId, 'groupId');
         });
         it('joins a MLS conversation if it was sent an orphan welcome message', async () => {
-            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
+            const [conversationService, { mlsService }] = await buildConversationService();
             const conversationId = { id: 'conversationId', domain: 'staging.zinfra.io' };
             const mockMLSWelcomeMessageEvent = createMLSWelcomeMessageEventMock(conversationId);
             const orphanWelcomeMessageError = new Error();
-            orphanWelcomeMessageError.name = CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorOrphanWelcomeMessage;
+            // Simulate core-crypto orphan welcome classification for mapper
+            orphanWelcomeMessageError.name = core_crypto_1.MlsErrorType.OrphanWelcome;
+            orphanWelcomeMessageError.context = { type: core_crypto_1.MlsErrorType.OrphanWelcome };
+            orphanWelcomeMessageError.type = core_crypto_1.ErrorType.Mls;
             jest.spyOn(mlsService, 'handleMLSWelcomeMessageEvent').mockRejectedValueOnce(orphanWelcomeMessageError);
-            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
-                qualified_id: conversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
-            });
+            // Ensure welcome processing is attempted (succeeds after recovery join)
+            jest.spyOn(mlsService, 'handleMLSWelcomeMessageEvent').mockResolvedValueOnce(undefined);
             await conversationService.handleEvent(mockMLSWelcomeMessageEvent);
             await new Promise(resolve => setImmediate(resolve));
-            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(conversationId);
+            // Orchestrator triggers a low-level join (performJoinByExternalCommitAPI -> mlsService.joinByExternalCommit)
+            expect(mlsService.joinByExternalCommit).toHaveBeenCalled();
+        });
+        it('wipes local MLS state and retries when welcome fails with ConversationAlreadyExists', async () => {
+            const [conversationService, { mlsService }] = await buildConversationService();
+            const conversationId = { id: 'conversationId', domain: 'staging.zinfra.io' };
+            const mockMLSWelcomeMessageEvent = createMLSWelcomeMessageEventMock(conversationId);
+            // Create a base64 group id and its byte-array form to simulate core-crypto error context
+            const expectedGroupId = 'AXNhbXBsZQ=='; // base64 for '\u0001sample'
+            const conversationIdArray = Array.from(Buffer.from(expectedGroupId, 'base64'));
+            const existsError = {};
+            // Simulate core-crypto "conversation already exists" classification for the mapper
+            existsError.type = core_crypto_1.ErrorType.Mls;
+            existsError.context = {
+                type: core_crypto_1.MlsErrorType.ConversationAlreadyExists,
+                context: { conversationId: conversationIdArray },
+            };
+            const welcomeSpy = jest
+                .spyOn(mlsService, 'handleMLSWelcomeMessageEvent')
+                .mockRejectedValueOnce(existsError)
+                .mockResolvedValueOnce(undefined);
+            await conversationService.handleEvent(mockMLSWelcomeMessageEvent);
+            await new Promise(resolve => setImmediate(resolve));
+            // Expect a single wipe with the extracted group id, and a single retry of welcome handling
+            expect(mlsService.wipeConversation).toHaveBeenCalledTimes(1);
+            expect(mlsService.wipeConversation).toHaveBeenCalledWith(expectedGroupId);
+            expect(welcomeSpy).toHaveBeenCalledTimes(2);
         });
     });
     describe('getConversations', () => {
@@ -511,21 +687,22 @@ describe('ConversationService', () => {
                 .map(() => ({ id: PayloadHelper.getUUID(), domain: 'local.wire.com' }));
             const selfUserToAdd = { id: 'self-user-id', domain: 'local.wire.com', skipOwnClientId: apiClient.clientId };
             const qualifiedUsers = [...otherUsersToAdd, selfUserToAdd];
-            jest.spyOn(mlsService, 'getKeyPackagesPayload').mockResolvedValueOnce({ keyPackages: [], failures: [] });
+            jest
+                .spyOn(mlsService, 'getKeyPackagesPayload')
+                .mockResolvedValueOnce({ keyPackages: [new Uint8Array(0)], failures: [] });
             jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: 1,
                 group_id: mockGroupId,
             });
-            const mlsMessage = { events: [], time: '', failures: [] };
-            jest.spyOn(mlsService, 'addUsersToExistingConversation').mockResolvedValueOnce(mlsMessage);
+            jest.spyOn(mlsService, 'addUsersToExistingConversation');
             await conversationService.addUsersToMLSConversation({
                 qualifiedUsers,
                 groupId: mockGroupId,
                 conversationId: mockConversationId,
             });
-            expect(mlsService.getKeyPackagesPayload).toHaveBeenCalledWith(qualifiedUsers);
+            expect(mlsService.getKeyPackagesPayload).toHaveBeenCalledWith(qualifiedUsers, undefined);
             expect(mlsService.resetKeyMaterialRenewal).toHaveBeenCalledWith(mockGroupId);
         });
         it('should return failure reasons for users it was not possible to claim keys for', async () => {
@@ -541,20 +718,11 @@ describe('ConversationService', () => {
                 reason: __1.AddUsersFailureReasons.OFFLINE_FOR_TOO_LONG,
                 users: [otherUsersToAdd[0]],
             };
-            const addUsersFailure = {
-                reason: __1.AddUsersFailureReasons.UNREACHABLE_BACKENDS,
-                users: [otherUsersToAdd[1]],
-                backends: [otherUsersToAdd[1].domain],
-            };
-            const mlsFailure = {
-                reason: __1.AddUsersFailureReasons.NOT_MLS_CAPABLE,
-                users: [otherUsersToAdd[2]],
-            };
             jest.spyOn(apiClient.api.user, 'getUserSupportedProtocols').mockImplementation(id => {
                 if (id === otherUsersToAdd[2]) {
-                    return Promise.resolve([conversation_1.ConversationProtocol.PROTEUS]);
+                    return Promise.resolve([team_1.CONVERSATION_PROTOCOL.PROTEUS]);
                 }
-                return Promise.resolve([conversation_1.ConversationProtocol.MLS, conversation_1.ConversationProtocol.PROTEUS]);
+                return Promise.resolve([team_1.CONVERSATION_PROTOCOL.MLS, team_1.CONVERSATION_PROTOCOL.PROTEUS]);
             });
             jest.spyOn(mlsService, 'getKeyPackagesPayload').mockResolvedValueOnce({
                 keyPackages: [new Uint8Array(0)],
@@ -562,18 +730,63 @@ describe('ConversationService', () => {
             });
             jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: conversation_1.ConversationProtocol.MLS,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
                 epoch: 1,
                 group_id: mockGroupId,
             });
-            const mlsMessage = { events: [], time: '', failures: [addUsersFailure] };
-            jest.spyOn(mlsService, 'addUsersToExistingConversation').mockResolvedValueOnce(mlsMessage);
+            jest.spyOn(mlsService, 'addUsersToExistingConversation');
             const { failedToAdd } = await conversationService.addUsersToMLSConversation({
                 qualifiedUsers,
                 groupId: mockGroupId,
                 conversationId: mockConversationId,
             });
-            expect(failedToAdd).toEqual([keysClaimingFailure, addUsersFailure, mlsFailure]);
+            expect(failedToAdd).toEqual([keysClaimingFailure]);
+        });
+        it('recovers and retries when stale-message occurs during add users commit upload', async () => {
+            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
+            const mockGroupId = 'groupId-stale-add';
+            const mockConversationId = { id: PayloadHelper.getUUID(), domain: 'local.wire.com' };
+            const otherUsersToAdd = Array(2)
+                .fill(0)
+                .map(() => ({ id: PayloadHelper.getUUID(), domain: 'local.wire.com' }));
+            const qualifiedUsers = [...otherUsersToAdd];
+            const staleMessageError = {
+                type: core_crypto_1.ErrorType.Mls,
+                context: {
+                    type: core_crypto_1.MlsErrorType.MessageRejected,
+                    context: {
+                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }),
+                    },
+                },
+            };
+            const getKPSpy = jest.spyOn(mlsService, 'getKeyPackagesPayload');
+            getKPSpy.mockResolvedValue({
+                keyPackages: [new Uint8Array(0)],
+                failures: [],
+            });
+            // Simulate commit upload failing once with stale, then succeeding
+            jest
+                .spyOn(mlsService, 'addUsersToExistingConversation')
+                .mockRejectedValueOnce(staleMessageError)
+                .mockResolvedValueOnce(undefined);
+            const remoteEpoch = 5;
+            const localEpoch = 4;
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
+            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
+            const getConvSpy = jest.spyOn(apiClient.api.conversation, 'getConversation');
+            getConvSpy.mockResolvedValue({
+                qualified_id: mockConversationId,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                epoch: remoteEpoch,
+                group_id: mockGroupId,
+            });
+            await conversationService.addUsersToMLSConversation({
+                qualifiedUsers,
+                groupId: mockGroupId,
+                conversationId: mockConversationId,
+            });
+            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(mockConversationId);
+            expect(mlsService.addUsersToExistingConversation).toHaveBeenCalledTimes(2);
         });
     });
     describe('tryEstablishingMLSGroup', () => {
@@ -620,6 +833,186 @@ describe('ConversationService', () => {
             expect(conversationService.addUsersToMLSConversation).not.toHaveBeenCalled();
         });
     });
+    describe('reactToKeyMaterialUpdateFailure', () => {
+        function getKeyMaterialFailureHandler(mlsService) {
+            const onMock = mlsService.on;
+            const call = onMock.mock.calls.find(([event]) => event === MLSService_1.MLSServiceEvents.KEY_MATERIAL_UPDATE_FAILURE);
+            expect(call).toBeTruthy();
+            return call[1];
+        }
+        it('resets a broken MLS conversation', async () => {
+            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
+            const groupId = 'group-1';
+            const qualified_id = { id: 'conv-1', domain: 'staging.zinfra.io' };
+            jest.spyOn(apiClient.api.conversation, 'getConversationList').mockResolvedValueOnce({
+                found: [{ group_id: groupId, qualified_id, protocol: team_1.CONVERSATION_PROTOCOL.MLS, epoch: 1 }],
+            });
+            const resetSpy = jest
+                .spyOn(conversationService, 'handleBrokenMLSConversation')
+                .mockResolvedValue(undefined);
+            const addUsersSpy = jest.spyOn(conversationService, 'addUsersToMLSConversation');
+            const handler = getKeyMaterialFailureHandler(mlsService);
+            const brokenErr = {
+                type: core_crypto_1.ErrorType.Mls,
+                context: {
+                    type: core_crypto_1.MlsErrorType.MessageRejected,
+                    context: {
+                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.BROKEN_MLS_CONVERSATION }),
+                    },
+                },
+            };
+            await handler({ error: brokenErr, groupId });
+            expect(resetSpy).toHaveBeenCalledWith(qualified_id);
+            expect(addUsersSpy).not.toHaveBeenCalled();
+        });
+        it('adds missing users when group is out of sync', async () => {
+            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
+            const groupId = 'group-2';
+            const qualified_id = { id: 'conv-2', domain: 'staging.zinfra.io' };
+            const missingUsers = [
+                { id: 'u1', domain: 'staging.zinfra.io' },
+                { id: 'u2', domain: 'staging.zinfra.io' },
+            ];
+            jest.spyOn(apiClient.api.conversation, 'getConversationList').mockResolvedValueOnce({
+                found: [{ group_id: groupId, qualified_id, protocol: team_1.CONVERSATION_PROTOCOL.MLS, epoch: 1 }],
+            });
+            const addUsersSpy = jest
+                .spyOn(conversationService, 'performAddUsersToMLSConversationAPI')
+                .mockResolvedValue({ conversation: {} });
+            const resetSpy = jest
+                .spyOn(conversationService, 'handleBrokenMLSConversation')
+                .mockResolvedValue(undefined);
+            const handler = getKeyMaterialFailureHandler(mlsService);
+            const outOfSyncErr = {
+                type: core_crypto_1.ErrorType.Mls,
+                context: {
+                    type: core_crypto_1.MlsErrorType.MessageRejected,
+                    context: {
+                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({
+                            message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_GROUP_OUT_OF_SYNC,
+                            missing_users: missingUsers,
+                        }),
+                    },
+                },
+            };
+            await handler({ error: outOfSyncErr, groupId });
+            expect(addUsersSpy).toHaveBeenCalledWith({
+                groupId,
+                conversationId: qualified_id,
+                qualifiedUsers: missingUsers,
+            });
+            expect(resetSpy).not.toHaveBeenCalled();
+        });
+        it('deduplicates concurrent recoveries for the same group id', async () => {
+            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
+            const groupId = 'group-dup';
+            const qualified_id = { id: 'conv-dup', domain: 'staging.zinfra.io' };
+            jest.spyOn(apiClient.api.conversation, 'getConversationList').mockResolvedValue({
+                found: [{ group_id: groupId, qualified_id, protocol: team_1.CONVERSATION_PROTOCOL.MLS, epoch: 1 }],
+            });
+            // Make the recovery hang until we resolve it, to simulate overlapping calls
+            let resolveDeferred;
+            const deferred = new Promise(res => (resolveDeferred = res));
+            const resetSpy = jest
+                .spyOn(conversationService, 'handleBrokenMLSConversation')
+                .mockReturnValue(deferred);
+            const handler = getKeyMaterialFailureHandler(mlsService);
+            const brokenErr = {
+                type: core_crypto_1.ErrorType.Mls,
+                context: {
+                    type: core_crypto_1.MlsErrorType.MessageRejected,
+                    context: {
+                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.BROKEN_MLS_CONVERSATION }),
+                    },
+                },
+            };
+            const p1 = handler({ error: brokenErr, groupId });
+            const p2 = handler({ error: brokenErr, groupId });
+            // Complete the first recovery
+            if (resolveDeferred) {
+                resolveDeferred();
+            }
+            await Promise.allSettled([p1, p2]);
+            expect(resetSpy).toHaveBeenCalledTimes(1);
+        });
+        it('handles stale-message by rejoining via external commit and emits recovery event', async () => {
+            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
+            const groupId = 'group-stale';
+            const qualified_id = { id: 'conv-stale', domain: 'staging.zinfra.io' };
+            jest.spyOn(apiClient.api.conversation, 'getConversationList').mockResolvedValueOnce({
+                found: [{ group_id: groupId, qualified_id, protocol: team_1.CONVERSATION_PROTOCOL.MLS, epoch: 2 }],
+            });
+            const handler = getKeyMaterialFailureHandler(mlsService);
+            const staleMessageError = {
+                type: core_crypto_1.ErrorType.Mls,
+                context: {
+                    type: core_crypto_1.MlsErrorType.MessageRejected,
+                    context: {
+                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }),
+                    },
+                },
+            };
+            const remoteEpoch = 3;
+            const localEpoch = 2;
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
+            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
+            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
+                qualified_id,
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                epoch: remoteEpoch,
+                group_id: groupId,
+            });
+            await handler({ error: staleMessageError, groupId });
+            // Expect a rejoin on stale and a recovery event
+            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(qualified_id);
+            expect(conversationService.emit).toHaveBeenCalledWith('MLSConversationRecovered', { conversationId: qualified_id });
+        });
+    });
+    describe('groupIdConversationMap cache', () => {
+        function makeConversation(group_id, id) {
+            return {
+                group_id,
+                qualified_id: { id, domain: 'staging.zinfra.io' },
+                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                epoch: 1,
+            };
+        }
+        it('refreshGroupIdConversationMap builds the cache from backend list', async () => {
+            const [conversationService, { apiClient }] = await buildConversationService();
+            const conv1 = makeConversation('g-1', 'c-1');
+            const conv2 = makeConversation('g-2', 'c-2');
+            const getListSpy = jest
+                .spyOn(apiClient.api.conversation, 'getConversationList')
+                .mockResolvedValueOnce({ found: [conv1, conv2] });
+            await conversationService.refreshGroupIdConversationMap();
+            expect(getListSpy).toHaveBeenCalledTimes(1);
+            // Validate through the private cache map
+            const cache = conversationService.groupIdConversationMap;
+            expect(cache.get('g-1')?.qualified_id.id).toBe('c-1');
+            expect(cache.get('g-2')?.qualified_id.id).toBe('c-2');
+        });
+        it('getConversationByGroupId uses cache when available without backend call', async () => {
+            const [conversationService, { apiClient }] = await buildConversationService();
+            const conv = makeConversation('g-hit', 'c-hit');
+            // Pre-populate cache
+            conversationService.groupIdConversationMap.set('g-hit', conv);
+            const getListSpy = jest
+                .spyOn(apiClient.api.conversation, 'getConversationList')
+                .mockImplementation(() => Promise.reject(new Error('should not be called')));
+            const result = await conversationService.getConversationByGroupId('g-hit');
+            expect(result?.qualified_id.id).toBe('c-hit');
+            expect(getListSpy).not.toHaveBeenCalled();
+        });
+        it('getConversationByGroupId refreshes on cache miss and returns undefined if not found', async () => {
+            const [conversationService, { apiClient }] = await buildConversationService();
+            const getListSpy = jest
+                .spyOn(apiClient.api.conversation, 'getConversationList')
+                .mockResolvedValueOnce({ found: [makeConversation('g-else', 'c-else')] });
+            const result = await conversationService.getConversationByGroupId('g-missing');
+            expect(result).toBeUndefined();
+            expect(getListSpy).toHaveBeenCalledTimes(1);
+        });
+    });
 });
 function generateImage() {
     const image = {
@@ -636,6 +1029,7 @@ function generateImage() {
             keyBytes: Buffer.from([]),
             sha256: Buffer.from([]),
             token: '',
+            domain: 'example.com',
         },
     };
 }