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

package/lib/messagingProtocols/mls/E2EIdentityService/Helper/index.js

@@ -18,7 +18,7 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isResponseStatusValid = exports.isMLSDevice = exports.getSignatureAlgorithmForCiphersuite = exports.getE2EIClientId = exports.jsonToByteArray = void 0;
+exports.isResponseStatusValid = exports.getMLSDeviceStatus = exports.MLSDeviceStatus = exports.isMLSDevice = exports.getSignatureAlgorithmForCiphersuite = exports.getE2EIClientId = exports.jsonToByteArray = void 0;
 const client_1 = require("@wireapp/api-client/lib/client");
 const core_crypto_1 = require("@wireapp/core-crypto");
 const fullyQualifiedClientIdUtils_1 = require("../../../../util/fullyQualifiedClientIdUtils");
@@ -58,5 +58,23 @@ const isMLSDevice = ({ mls_public_keys }, ciphersuite) => {
     return typeof signature === 'string' && signature.length > 0;
 };
 exports.isMLSDevice = isMLSDevice;
+var MLSDeviceStatus;
+(function (MLSDeviceStatus) {
+    MLSDeviceStatus["REGISTERED"] = "registered";
+    MLSDeviceStatus["FRESH"] = "fresh";
+    MLSDeviceStatus["MISMATCH"] = "mismatch";
+})(MLSDeviceStatus || (exports.MLSDeviceStatus = MLSDeviceStatus = {}));
+const getMLSDeviceStatus = ({ mls_public_keys }, ciphersuite, existingClientSignature) => {
+    const signatureAlogrithm = (0, exports.getSignatureAlgorithmForCiphersuite)(ciphersuite);
+    const signature = mls_public_keys[signatureAlogrithm];
+    if (!signature || !existingClientSignature) {
+        return MLSDeviceStatus.FRESH;
+    }
+    if (signature !== existingClientSignature) {
+        return MLSDeviceStatus.MISMATCH;
+    }
+    return MLSDeviceStatus.REGISTERED;
+};
+exports.getMLSDeviceStatus = getMLSDeviceStatus;
 const isResponseStatusValid = (status) => status && status === 'valid';
 exports.isResponseStatusValid = isResponseStatusValid;

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/IncomingProposalsQueue/IncomingProposalsQueue.d.ts

@@ -0,0 +1,7 @@
+import { Task } from '@wireapp/promise-queue';
+export declare function queueProposal<T>(cb: Task<T>): Promise<T>;
+export declare function resumeProposalProcessing(): void;
+export declare function pauseProposalProcessing(): void;
+export declare function getProposalQueueLength(): number;
+export declare function flushProposalsQueue(): void;
+//# sourceMappingURL=IncomingProposalsQueue.d.ts.map

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/IncomingProposalsQueue/IncomingProposalsQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IncomingProposalsQueue.d.ts","sourceRoot":"","sources":["../../../../../../../src/messagingProtocols/mls/EventHandler/events/messageAdd/IncomingProposalsQueue/IncomingProposalsQueue.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,IAAI,EAAe,MAAM,wBAAwB,CAAC;AAM1D,wBAAgB,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGxD;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAG/C;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAG9C;AAED,wBAAgB,sBAAsB,WAErC;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C"}

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/IncomingProposalsQueue/IncomingProposalsQueue.js

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2025 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queueProposal = queueProposal;
+exports.resumeProposalProcessing = resumeProposalProcessing;
+exports.pauseProposalProcessing = pauseProposalProcessing;
+exports.getProposalQueueLength = getProposalQueueLength;
+exports.flushProposalsQueue = flushProposalsQueue;
+const commons_1 = require("@wireapp/commons");
+const promise_queue_1 = require("@wireapp/promise-queue");
+const logger = commons_1.LogFactory.getLogger('@wireapp/core/mls/IncomingProposalsQueue');
+const proposalsQueue = new promise_queue_1.PromiseQueue({ name: 'incoming-proposals-queue', paused: true });
+function queueProposal(cb) {
+    logger.info('Queueing proposal for processing');
+    return proposalsQueue.push(cb);
+}
+function resumeProposalProcessing() {
+    logger.info('Resuming proposal processing');
+    proposalsQueue.resume();
+}
+function pauseProposalProcessing() {
+    logger.info('Pausing proposal processing');
+    proposalsQueue.pause();
+}
+function getProposalQueueLength() {
+    return proposalsQueue.getLength();
+}
+function flushProposalsQueue() {
+    logger.info('Flushing proposals queue');
+    proposalsQueue.flush();
+}

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/IncomingProposalsQueue/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IncomingProposalsQueue';
+//# sourceMappingURL=index.d.ts.map

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/{IncomingMessagesQueue → IncomingProposalsQueue}/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/messagingProtocols/mls/EventHandler/events/messageAdd/IncomingMessagesQueue/index.ts"],"names":[],"mappings":"AAmBA,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/messagingProtocols/mls/EventHandler/events/messageAdd/IncomingProposalsQueue/index.ts"],"names":[],"mappings":"AAmBA,cAAc,0BAA0B,CAAC"}

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/{IncomingMessagesQueue → IncomingProposalsQueue}/index.js

@@ -32,4 +32,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./IncomingMesssagesQueue"), exports);
+__exportStar(require("./IncomingProposalsQueue"), exports);

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/index.d.ts

@@ -1,3 +1,2 @@
 export * from './messageAdd';
-export * from './IncomingMessagesQueue';
 //# sourceMappingURL=index.d.ts.map

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/mls/EventHandler/events/messageAdd/index.ts"],"names":[],"mappings":"AAmBA,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/mls/EventHandler/events/messageAdd/index.ts"],"names":[],"mappings":"AAmBA,cAAc,cAAc,CAAC"}

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/index.js

@@ -33,4 +33,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./messageAdd"), exports);
-__exportStar(require("./IncomingMessagesQueue"), exports);

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/messageAdd.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messageAdd.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/mls/EventHandler/events/messageAdd/messageAdd.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,8BAA8B,EAAC,MAAM,+BAA+B,CAAC;AAG7E,OAAO,EAAC,mBAAmB,EAAC,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAC,UAAU,EAAuB,MAAM,gCAAgC,CAAC;AAEhF,UAAU,yBAAyB;IACjC,KAAK,EAAE,8BAA8B,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,eAAO,MAAM,mBAAmB,oCAI7B,yBAAyB,KAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAoChE,CAAC"}
+{"version":3,"file":"messageAdd.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/mls/EventHandler/events/messageAdd/messageAdd.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,8BAA8B,EAAC,MAAM,+BAA+B,CAAC;AAS7E,OAAO,EAAC,mBAAmB,EAAC,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAC,UAAU,EAAuB,MAAM,gCAAgC,CAAC;AAIhF,UAAU,yBAAyB;IACjC,KAAK,EAAE,8BAA8B,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,eAAO,MAAM,mBAAmB,oCAI7B,yBAAyB,KAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAoChE,CAAC"}

package/lib/messagingProtocols/mls/EventHandler/events/messageAdd/messageAdd.js

@@ -19,32 +19,41 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleMLSMessageAdd = void 0;
-const protocol_messaging_1 = require("@pydio/protocol-messaging");
 const bazinga64_1 = require("bazinga64");
+const commons_1 = require("@wireapp/commons");
+const core_crypto_1 = require("@wireapp/core-crypto");
+const protocol_messaging_1 = require("@wireapp/protocol-messaging");
+const IncomingProposalsQueue_1 = require("./IncomingProposalsQueue");
 const MLSService_1 = require("../../../MLSService/MLSService");
+const logger = commons_1.LogFactory.getLogger('@wireapp/core/mls/messageAdd');
 const handleMLSMessageAdd = async ({ event, groupId, mlsService, }) => {
     const encryptedData = bazinga64_1.Decoder.fromBase64(event.data).asBytes;
     const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-    const { proposals, commitDelay, message, senderClientId: encodedSenderClientId, hasEpochChanged, } = await mlsService.decryptMessage(groupIdBytes, encryptedData);
+    const decryptedMessage = await mlsService.decryptMessage(new core_crypto_1.ConversationId(groupIdBytes), encryptedData);
+    if (!decryptedMessage) {
+        // If the message is not decrypted, we return null
+        return null;
+    }
+    const { message, commitDelay, senderClientId: encodedSenderClientId } = decryptedMessage;
     if (encodedSenderClientId) {
         const decoder = new TextDecoder();
-        const senderClientId = decoder.decode((0, MLSService_1.optionalToUint8Array)(encodedSenderClientId));
+        const senderClientId = decoder.decode((0, MLSService_1.optionalToUint8Array)(encodedSenderClientId.copyBytes()));
         event.senderClientId = senderClientId;
     }
     // Check if the message includes proposals
-    if (typeof commitDelay === 'number' || proposals.length > 0) {
-        // we are dealing with a proposal, add a task to process this proposal later on
-        // Those proposals are stored inside of coreCrypto and will be handled after a timeout
-        await mlsService.handlePendingProposals({
-            groupId,
-            delayInMs: commitDelay ?? 0,
-            eventTime: event.time,
+    if (typeof commitDelay === 'number') {
+        (0, IncomingProposalsQueue_1.queueProposal)(async () => {
+            // we are dealing with a proposal, add a task to process this proposal later on
+            // Those proposals are stored inside of coreCrypto and will be handled after a timeout
+            await mlsService.handlePendingProposals({
+                groupId,
+                delayInMs: commitDelay ?? 0,
+                eventTime: event.time,
+            });
+        }).catch(error => {
+            logger.error('Failed to process proposal:', error);
         });
     }
-    if (hasEpochChanged) {
-        const newEpoch = await mlsService.getEpoch(groupId);
-        mlsService.emit('newEpoch', { groupId, epoch: newEpoch });
-    }
     return message ? { event, decryptedData: protocol_messaging_1.GenericMessage.decode(message) } : null;
 };
 exports.handleMLSMessageAdd = handleMLSMessageAdd;

package/lib/messagingProtocols/mls/EventHandler/events/welcomeMessage/welcomeMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"welcomeMessage.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/mls/EventHandler/events/welcomeMessage/welcomeMessage.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,2BAA2B,EAAC,MAAM,+BAA+B,CAAC;AAG1E,OAAO,EAAC,mBAAmB,EAAC,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAC,UAAU,EAAC,MAAM,qBAAqB,CAAC;AAE/C,UAAU,0BAA0B;IAClC,KAAK,EAAE,2BAA2B,CAAC;IACnC,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,eAAO,MAAM,uBAAuB,2BAGjC,0BAA0B,KAAG,OAAO,CAAC,mBAAmB,CAiB1D,CAAC"}
+{"version":3,"file":"welcomeMessage.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/mls/EventHandler/events/welcomeMessage/welcomeMessage.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,2BAA2B,EAAC,MAAM,+BAA+B,CAAC;AAG1E,OAAO,EAAC,mBAAmB,EAAC,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAC,UAAU,EAAmB,MAAM,qBAAqB,CAAC;AAEjE,UAAU,0BAA0B;IAClC,KAAK,EAAE,2BAA2B,CAAC;IACnC,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,eAAO,MAAM,uBAAuB,2BAGjC,0BAA0B,KAAG,OAAO,CAAC,mBAAmB,CAmB1D,CAAC"}

package/lib/messagingProtocols/mls/EventHandler/events/welcomeMessage/welcomeMessage.js

@@ -20,16 +20,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleMLSWelcomeMessage = void 0;
 const bazinga64_1 = require("bazinga64");
+const MLSService_1 = require("../../../MLSService");
 const handleMLSWelcomeMessage = async ({ mlsService, event, }) => {
     const data = bazinga64_1.Decoder.fromBase64(event.data).asBytes;
     // We extract the groupId from the welcome message and let coreCrypto store this group
     const newGroupId = await mlsService.processWelcomeMessage(data);
-    const groupIdStr = bazinga64_1.Encoder.toBase64(newGroupId).asString;
+    const groupIdStr = bazinga64_1.Encoder.toBase64(newGroupId.copyBytes()).asString;
     // The groupId can then be sent back to the consumer
     // After we were added to the group we need to schedule a periodic key material renewal
     await mlsService.scheduleKeyMaterialRenewal(groupIdStr);
+    // We also need to emit a NEW_EPOCH event to notify the rest of the system that we have joined a new group
     const newEpoch = await mlsService.getEpoch(groupIdStr);
-    mlsService.emit('newEpoch', { groupId: groupIdStr, epoch: newEpoch });
+    mlsService.emit(MLSService_1.MLSServiceEvents.NEW_EPOCH, { groupId: groupIdStr, epoch: newEpoch });
+    mlsService.logger.info(`Joined MLS group with id ${groupIdStr} via welcome message, new epoch: ${newEpoch}`);
     return {
         event: { ...event, data: groupIdStr },
     };

package/lib/messagingProtocols/mls/EventHandler/events/welcomeMessage/welcomeMessage.test.js

@@ -19,7 +19,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const event_1 = require("@wireapp/api-client/lib/event");
+const core_crypto_1 = require("@wireapp/core-crypto");
 const welcomeMessage_1 = require("./welcomeMessage");
+const MLSService_1 = require("../../../MLSService");
 jest.mock('bazinga64', () => ({
     ...jest.requireActual('bazinga64'),
     Decoder: {
@@ -39,10 +41,15 @@ const mockParams = {
     },
     source: {},
     mlsService: {
-        processWelcomeMessage: jest.fn().mockResolvedValue('conversationId'),
+        processWelcomeMessage: jest.fn().mockResolvedValue(new core_crypto_1.Welcome(Uint8Array.from([1, 2, 3]))),
         scheduleKeyMaterialRenewal: jest.fn(),
         getEpoch: jest.fn(),
         emit: jest.fn(),
+        logger: {
+            info: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+        },
     },
     dryRun: false,
 };
@@ -56,12 +63,15 @@ describe('MLS welcomeMessage eventHandler', () => {
         it('returns a eventHandlerResult', async () => {
             const eventHandlerResult = await (0, welcomeMessage_1.handleMLSWelcomeMessage)(mockParams);
             expect(eventHandlerResult).toBeDefined();
-            expect(eventHandlerResult.event).toEqual({ data: 'conversationId', type: 'conversation.mls-welcome' });
+            expect(eventHandlerResult.event).toEqual({ data: Uint8Array.from([1, 2, 3]), type: 'conversation.mls-welcome' });
         });
         it('emits new epoch event after processing a welcome message', async () => {
             jest.spyOn(mockParams.mlsService, 'getEpoch').mockResolvedValue(1);
             await (0, welcomeMessage_1.handleMLSWelcomeMessage)(mockParams);
-            expect(mockParams.mlsService.emit).toHaveBeenCalledWith('newEpoch', { groupId: 'conversationId', epoch: 1 });
+            expect(mockParams.mlsService.emit).toHaveBeenCalledWith(MLSService_1.MLSServiceEvents.NEW_EPOCH, {
+                groupId: Uint8Array.from([1, 2, 3]),
+                epoch: 1,
+            });
         });
     });
 });

package/lib/messagingProtocols/mls/MLSService/CoreCryptoMLSError.d.ts

@@ -1,3 +1,5 @@
+import { QualifiedId } from '@wireapp/api-client/lib/user';
+import { CoreCryptoError, ErrorContext, ErrorType, MlsErrorType } from '@wireapp/core-crypto';
 export declare const CORE_CRYPTO_ERROR_NAMES: {
     MlsErrorConversationAlreadyExists: string;
     MlsErrorDuplicateMessage: string;
@@ -11,10 +13,44 @@ export declare const CORE_CRYPTO_ERROR_NAMES: {
     ProteusErrorSessionNotFound: string;
     ProteusErrorRemoteIdentityChanged: string;
     MlsErrorWrongEpoch: string;
-    MlsErrorOrphanWelcomeMessage: string;
 };
 export declare const isCoreCryptoMLSWrongEpochError: (error: unknown) => boolean;
 export declare const isCoreCryptoMLSConversationAlreadyExistsError: (error: unknown) => boolean;
-export declare const isCoreCryptoMLSOrphanWelcomeMessageError: (error: unknown) => boolean;
 export declare const shouldMLSDecryptionErrorBeIgnored: (error: unknown) => error is Error;
+export declare const UPLOAD_COMMIT_BUNDLE_ABORT_REASONS: {
+    BROKEN_MLS_CONVERSATION: string;
+    MLS_STALE_MESSAGE: string;
+    MLS_GROUP_OUT_OF_SYNC: string;
+    OTHER: string;
+};
+export type ConversationAlreadyExistsError = CoreCryptoError<ErrorType.Mls> & {
+    context: Extract<ErrorContext[ErrorType.Mls], {
+        type: MlsErrorType.ConversationAlreadyExists;
+    }>;
+};
+type MessageRejectedError = CoreCryptoError<ErrorType.Mls> & {
+    context: Extract<ErrorContext[ErrorType.Mls], {
+        type: MlsErrorType.MessageRejected;
+    }>;
+};
+export declare function isBrokenMLSConversationError(error: unknown): error is MessageRejectedError;
+export declare function isMLSStaleMessageError(error: unknown): error is MessageRejectedError;
+export declare function isMLSGroupOutOfSyncError(error: unknown): error is MessageRejectedError;
+export declare function getMLSGroupOutOfSyncErrorMissingUsers(error: unknown): QualifiedId[];
+type AbortReasonBrokenMLSConversation = {
+    message: typeof UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.BROKEN_MLS_CONVERSATION;
+};
+type AbortReasonMLSStaleMessage = {
+    message: typeof UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE;
+};
+type AbortReasonMLSGroupOutOfSync = {
+    message: typeof UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_GROUP_OUT_OF_SYNC;
+    missing_users: QualifiedId[];
+};
+type AbortReasonOther = {
+    message: typeof UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.OTHER;
+};
+type AbortReasons = AbortReasonBrokenMLSConversation | AbortReasonMLSStaleMessage | AbortReasonMLSGroupOutOfSync | AbortReasonOther;
+export declare function serializeAbortReason(reason: AbortReasons): string;
+export {};
 //# sourceMappingURL=CoreCryptoMLSError.d.ts.map

package/lib/messagingProtocols/mls/MLSService/CoreCryptoMLSError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CoreCryptoMLSError.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/mls/MLSService/CoreCryptoMLSError.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;CAcnC,CAAC;AAEF,eAAO,MAAM,8BAA8B,UAAW,OAAO,KAAG,OAE/D,CAAC;AAEF,eAAO,MAAM,6CAA6C,UAAW,OAAO,KAAG,OAE9E,CAAC;AAEF,eAAO,MAAM,wCAAwC,UAAW,OAAO,KAAG,OAEzE,CAAC;AAoBF,eAAO,MAAM,iCAAiC,UAAW,OAAO,KAAG,KAAK,IAAI,KAI3E,CAAC"}
+{"version":3,"file":"CoreCryptoMLSError.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/mls/MLSService/CoreCryptoMLSError.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AAEzD,OAAO,EAAC,eAAe,EAAE,YAAY,EAAE,SAAS,EAA6B,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAEvH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;CAanC,CAAC;AAEF,eAAO,MAAM,8BAA8B,UAAW,OAAO,KAAG,OAE/D,CAAC;AAEF,eAAO,MAAM,6CAA6C,UAAW,OAAO,KAAG,OAE9E,CAAC;AAoBF,eAAO,MAAM,iCAAiC,UAAW,OAAO,KAAG,KAAK,IAAI,KAI3E,CAAC;AAEF,eAAO,MAAM,kCAAkC;;;;;CAK9C,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG;IAC5E,OAAO,EAAE,OAAO,CACd,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,EAC3B;QACE,IAAI,EAAE,YAAY,CAAC,yBAAyB,CAAC;KAC9C,CACF,CAAC;CACH,CAAC;AAEF,KAAK,oBAAoB,GAAG,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG;IAC3D,OAAO,EAAE,OAAO,CACd,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,EAC3B;QACE,IAAI,EAAE,YAAY,CAAC,eAAe,CAAC;KACpC,CACF,CAAC;CACH,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAM1F;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAMpF;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAMtF;AAED,wBAAgB,qCAAqC,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,EAAE,CAOnF;AAED,KAAK,gCAAgC,GAAG;IACtC,OAAO,EAAE,OAAO,kCAAkC,CAAC,uBAAuB,CAAC;CAC5E,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,OAAO,EAAE,OAAO,kCAAkC,CAAC,iBAAiB,CAAC;CACtE,CAAC;AAEF,KAAK,4BAA4B,GAAG;IAClC,OAAO,EAAE,OAAO,kCAAkC,CAAC,qBAAqB,CAAC;IACzE,aAAa,EAAE,WAAW,EAAE,CAAC;CAC9B,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,OAAO,EAAE,OAAO,kCAAkC,CAAC,KAAK,CAAC;CAC1D,CAAC;AAEF,KAAK,YAAY,GACb,gCAAgC,GAChC,0BAA0B,GAC1B,4BAA4B,GAC5B,gBAAgB,CAAC;AAErB,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAEjE"}

package/lib/messagingProtocols/mls/MLSService/CoreCryptoMLSError.js

@@ -18,7 +18,13 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldMLSDecryptionErrorBeIgnored = exports.isCoreCryptoMLSOrphanWelcomeMessageError = exports.isCoreCryptoMLSConversationAlreadyExistsError = exports.isCoreCryptoMLSWrongEpochError = exports.CORE_CRYPTO_ERROR_NAMES = void 0;
+exports.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS = exports.shouldMLSDecryptionErrorBeIgnored = exports.isCoreCryptoMLSConversationAlreadyExistsError = exports.isCoreCryptoMLSWrongEpochError = exports.CORE_CRYPTO_ERROR_NAMES = void 0;
+exports.isBrokenMLSConversationError = isBrokenMLSConversationError;
+exports.isMLSStaleMessageError = isMLSStaleMessageError;
+exports.isMLSGroupOutOfSyncError = isMLSGroupOutOfSyncError;
+exports.getMLSGroupOutOfSyncErrorMissingUsers = getMLSGroupOutOfSyncErrorMissingUsers;
+exports.serializeAbortReason = serializeAbortReason;
+const core_crypto_1 = require("@wireapp/core-crypto");
 exports.CORE_CRYPTO_ERROR_NAMES = {
     MlsErrorConversationAlreadyExists: 'MlsErrorConversationAlreadyExists',
     MlsErrorDuplicateMessage: 'MlsErrorDuplicateMessage',
@@ -32,7 +38,6 @@ exports.CORE_CRYPTO_ERROR_NAMES = {
     ProteusErrorSessionNotFound: 'ProteusErrorSessionNotFound',
     ProteusErrorRemoteIdentityChanged: 'ProteusErrorRemoteIdentityChanged',
     MlsErrorWrongEpoch: 'MlsErrorWrongEpoch',
-    MlsErrorOrphanWelcomeMessage: 'MlsErrorOrphanWelcomeMessage',
 };
 const isCoreCryptoMLSWrongEpochError = (error) => {
     return error instanceof Error && error.name === exports.CORE_CRYPTO_ERROR_NAMES.MlsErrorWrongEpoch;
@@ -42,10 +47,6 @@ const isCoreCryptoMLSConversationAlreadyExistsError = (error) => {
     return error instanceof Error && error.name === exports.CORE_CRYPTO_ERROR_NAMES.MlsErrorConversationAlreadyExists;
 };
 exports.isCoreCryptoMLSConversationAlreadyExistsError = isCoreCryptoMLSConversationAlreadyExistsError;
-const isCoreCryptoMLSOrphanWelcomeMessageError = (error) => {
-    return error instanceof Error && error.name === exports.CORE_CRYPTO_ERROR_NAMES.MlsErrorOrphanWelcomeMessage;
-};
-exports.isCoreCryptoMLSOrphanWelcomeMessageError = isCoreCryptoMLSOrphanWelcomeMessageError;
 const mlsDecryptionErrorNamesToIgnore = [
     exports.CORE_CRYPTO_ERROR_NAMES.MlsErrorStaleCommit,
     exports.CORE_CRYPTO_ERROR_NAMES.MlsErrorStaleProposal,
@@ -64,3 +65,37 @@ const shouldMLSDecryptionErrorBeIgnored = (error) => {
     return (error instanceof Error && (mlsDecryptionErrorNamesToIgnore.includes(error.name) || isOtherErrorToIgnore(error)));
 };
 exports.shouldMLSDecryptionErrorBeIgnored = shouldMLSDecryptionErrorBeIgnored;
+exports.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS = {
+    BROKEN_MLS_CONVERSATION: 'BROKEN_MLS_CONVERSATION',
+    MLS_STALE_MESSAGE: 'MLS_STALE_MESSAGE',
+    MLS_GROUP_OUT_OF_SYNC: 'MLS_GROUP_OUT_OF_SYNC',
+    OTHER: 'OTHER',
+};
+function isBrokenMLSConversationError(error) {
+    return ((0, core_crypto_1.isMlsMessageRejectedError)(error) &&
+        deserializeAbortReason(error.context.context.reason).message ===
+            exports.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.BROKEN_MLS_CONVERSATION);
+}
+function isMLSStaleMessageError(error) {
+    return ((0, core_crypto_1.isMlsMessageRejectedError)(error) &&
+        deserializeAbortReason(error.context.context.reason).message ===
+            exports.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE);
+}
+function isMLSGroupOutOfSyncError(error) {
+    return ((0, core_crypto_1.isMlsMessageRejectedError)(error) &&
+        deserializeAbortReason(error.context.context.reason).message ===
+            exports.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_GROUP_OUT_OF_SYNC);
+}
+function getMLSGroupOutOfSyncErrorMissingUsers(error) {
+    if (isMLSGroupOutOfSyncError(error)) {
+        const reason = deserializeAbortReason(error.context.context.reason);
+        return reason.missing_users;
+    }
+    throw new Error('Error is not MLSGroupOutOfSyncError');
+}
+function serializeAbortReason(reason) {
+    return JSON.stringify(reason);
+}
+function deserializeAbortReason(reasonString) {
+    return JSON.parse(reasonString);
+}

package/lib/messagingProtocols/mls/MLSService/CoreCryptoMLSError.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CoreCryptoMLSError.test.d.ts.map

package/lib/messagingProtocols/mls/MLSService/CoreCryptoMLSError.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoreCryptoMLSError.test.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/mls/MLSService/CoreCryptoMLSError.test.ts"],"names":[],"mappings":""}

package/lib/messagingProtocols/mls/MLSService/CoreCryptoMLSError.test.js

@@ -0,0 +1,124 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2025 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_crypto_1 = require("@wireapp/core-crypto");
+const CoreCryptoMLSError_1 = require("./CoreCryptoMLSError");
+describe('CoreCryptoMLSError helpers', () => {
+    describe('epoch and conversation existence guards', () => {
+        it('detects MlsErrorWrongEpoch by name', () => {
+            const err = new Error('wrong epoch');
+            err.name = CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorWrongEpoch;
+            expect((0, CoreCryptoMLSError_1.isCoreCryptoMLSWrongEpochError)(err)).toBe(true);
+            const other = new Error('nope');
+            expect((0, CoreCryptoMLSError_1.isCoreCryptoMLSWrongEpochError)(other)).toBe(false);
+            expect((0, CoreCryptoMLSError_1.isCoreCryptoMLSWrongEpochError)('not-an-error')).toBe(false);
+        });
+        it('detects MlsErrorConversationAlreadyExists by name', () => {
+            const err = new Error('already exists');
+            err.name = CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorConversationAlreadyExists;
+            expect((0, CoreCryptoMLSError_1.isCoreCryptoMLSConversationAlreadyExistsError)(err)).toBe(true);
+            const other = new Error('nope');
+            expect((0, CoreCryptoMLSError_1.isCoreCryptoMLSConversationAlreadyExistsError)(other)).toBe(false);
+            expect((0, CoreCryptoMLSError_1.isCoreCryptoMLSConversationAlreadyExistsError)(42)).toBe(false);
+        });
+    });
+    describe('shouldMLSDecryptionErrorBeIgnored', () => {
+        const namesToIgnore = [
+            CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorStaleCommit,
+            CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorStaleProposal,
+            CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorDuplicateMessage,
+            CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorBufferedFutureMessage,
+            CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorUnmergedPendingGroup,
+        ];
+        it('returns true for known ignorable error names', () => {
+            for (const name of namesToIgnore) {
+                const err = new Error('ignore me');
+                err.name = name;
+                expect((0, CoreCryptoMLSError_1.shouldMLSDecryptionErrorBeIgnored)(err)).toBe(true);
+            }
+        });
+        it('returns true for generic MlsErrorOther with expected commit/proposals message', () => {
+            const err = new Error('Incoming message is a commit for which we have not yet received all the proposals: details...');
+            err.name = CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorOther;
+            expect((0, CoreCryptoMLSError_1.shouldMLSDecryptionErrorBeIgnored)(err)).toBe(true);
+        });
+        it('returns false for other errors or non-Error values', () => {
+            const err = new Error('some real failure');
+            err.name = 'RandomErrorName';
+            expect((0, CoreCryptoMLSError_1.shouldMLSDecryptionErrorBeIgnored)(err)).toBe(false);
+            expect((0, CoreCryptoMLSError_1.shouldMLSDecryptionErrorBeIgnored)('not-an-error')).toBe(false);
+        });
+    });
+    describe('abort reason based guards', () => {
+        function makeRejectedError(reason) {
+            return {
+                type: core_crypto_1.ErrorType.Mls,
+                context: {
+                    type: core_crypto_1.MlsErrorType.MessageRejected,
+                    context: {
+                        reason,
+                    },
+                },
+            };
+        }
+        it('detects broken MLS conversation errors', () => {
+            const err = makeRejectedError((0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.BROKEN_MLS_CONVERSATION }));
+            expect((0, CoreCryptoMLSError_1.isBrokenMLSConversationError)(err)).toBe(true);
+            expect((0, CoreCryptoMLSError_1.isMLSStaleMessageError)(err)).toBe(false);
+            expect((0, CoreCryptoMLSError_1.isMLSGroupOutOfSyncError)(err)).toBe(false);
+        });
+        it('detects MLS stale message errors', () => {
+            const err = makeRejectedError((0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }));
+            expect((0, CoreCryptoMLSError_1.isMLSStaleMessageError)(err)).toBe(true);
+            expect((0, CoreCryptoMLSError_1.isBrokenMLSConversationError)(err)).toBe(false);
+            expect((0, CoreCryptoMLSError_1.isMLSGroupOutOfSyncError)(err)).toBe(false);
+        });
+        it('detects MLS group out-of-sync errors and exposes missing users', () => {
+            const missing = [
+                { id: 'u1', domain: 'example.com' },
+                { id: 'u2', domain: 'example.com' },
+            ];
+            const err = makeRejectedError((0, CoreCryptoMLSError_1.serializeAbortReason)({
+                message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_GROUP_OUT_OF_SYNC,
+                missing_users: missing,
+            }));
+            expect((0, CoreCryptoMLSError_1.isMLSGroupOutOfSyncError)(err)).toBe(true);
+            expect((0, CoreCryptoMLSError_1.getMLSGroupOutOfSyncErrorMissingUsers)(err)).toEqual(missing);
+        });
+        it('throws when getting missing users from non-MLSGroupOutOfSync error', () => {
+            const err = makeRejectedError((0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }));
+            expect(() => (0, CoreCryptoMLSError_1.getMLSGroupOutOfSyncErrorMissingUsers)(err)).toThrow('Error is not MLSGroupOutOfSyncError');
+        });
+        it('returns false for non-mls message rejected errors', () => {
+            const err = {
+                type: core_crypto_1.ErrorType.Mls,
+                context: {
+                    type: core_crypto_1.MlsErrorType.Other,
+                    context: {
+                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }),
+                    },
+                },
+            };
+            expect((0, CoreCryptoMLSError_1.isBrokenMLSConversationError)(err)).toBe(false);
+            expect((0, CoreCryptoMLSError_1.isMLSStaleMessageError)(err)).toBe(false);
+            expect((0, CoreCryptoMLSError_1.isMLSGroupOutOfSyncError)(err)).toBe(false);
+        });
+    });
+});