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

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

@@ -17,6 +17,29 @@
  * along with this program. If not, see http://www.gnu.org/licenses/.
  *
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const client_1 = require("@wireapp/api-client/lib/client");
 const event_1 = require("@wireapp/api-client/lib/event");
@@ -31,6 +54,11 @@ const conversation_1 = require("../../../conversation");
 const CoreDB_1 = require("../../../storage/CoreDB");
 const RecurringTaskScheduler_1 = require("../../../util/RecurringTaskScheduler");
 const TaskScheduler_1 = require("../../../util/TaskScheduler");
+const Helper = __importStar(require("../E2EIdentityService/Helper"));
+jest.mock('../E2EIdentityService/Helper', () => ({
+    ...jest.requireActual('../E2EIdentityService/Helper'),
+    getMLSDeviceStatus: jest.fn(),
+}));
 jest.createMockFromModule('@wireapp/api-client');
 function createUserId() {
     return { id: (0, crypto_1.randomUUID)(), domain: '' };
@@ -39,25 +67,36 @@ const defaultMLSInitConfig = {
     ciphersuites: [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519],
     defaultCiphersuite: core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519,
 };
+// Needs to be divisible by 4 to be a valid base64 string
+const mockGroupId = 'Z3JvdXAtdGVzdC0x';
+const mockedMLSWelcomeEventData = '';
+const apiClients = [];
 const createMLSService = async () => {
     const apiClient = new api_client_1.APIClient();
-    const mockCoreCrypto = {
-        createConversation: jest.fn(),
-        conversationExists: jest.fn(),
+    apiClients.push(apiClient);
+    const transactionContext = {
+        mlsInit: jest.fn(),
         wipeConversation: jest.fn(),
-        clientValidKeypackagesCount: jest.fn(),
         clientKeypackages: jest.fn(),
-        mlsInit: jest.fn(),
-        clientPublicKey: jest.fn(),
+        createConversation: jest.fn(),
+        clientValidKeypackagesCount: jest.fn(),
+        conversationExists: jest.fn(),
         processWelcomeMessage: jest.fn(),
-        conversationEpoch: jest.fn(),
         commitPendingProposals: jest.fn(),
-        registerCallbacks: jest.fn(),
+        decryptMessage: jest.fn(),
+        updateKeyingMaterial: jest.fn(),
+    };
+    const mockCoreCrypto = {
+        transaction: jest.fn(fn => {
+            return fn(transactionContext);
+        }),
+        registerEpochObserver: jest.fn(),
+        provideTransport: jest.fn(),
+        version: jest.fn(),
+        conversationExists: jest.fn(),
         e2eiIsEnabled: jest.fn(() => false),
-        clearPendingGroupFromExternalCommit: async () => { },
-        clearPendingCommit: async () => { },
-        commitAccepted: jest.fn(),
-        transaction: jest.fn(),
+        clientPublicKey: jest.fn(),
+        conversationEpoch: jest.fn(),
     };
     const mockedDb = await (0, CoreDB_1.openDB)('core-test-db');
     const recurringTaskScheduler = new RecurringTaskScheduler_1.RecurringTaskScheduler({
@@ -69,9 +108,15 @@ const createMLSService = async () => {
     });
     const mlsService = new MLSService_1.MLSService(apiClient, mockCoreCrypto, mockedDb, recurringTaskScheduler);
     mlsService['_config'] = { ...defaultMLSInitConfig, nbKeyPackages: 100, keyingMaterialUpdateThreshold: 1 };
-    return [mlsService, { apiClient, coreCrypto: mockCoreCrypto, recurringTaskScheduler }];
+    return [mlsService, { apiClient, coreCrypto: mockCoreCrypto, recurringTaskScheduler, transactionContext }];
 };
+afterAll(() => {
+    jest.clearAllTimers();
+});
 describe('MLSService', () => {
+    afterAll(() => {
+        apiClients.forEach(client => client.disconnect());
+    });
     describe('registerConversation', () => {
         let mlsService;
         let apiClient;
@@ -84,12 +129,6 @@ describe('MLSService', () => {
                 .mockResolvedValue({ removal: { ed25519: 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=' } });
             jest.spyOn(apiClient.api.client, 'claimMLSKeyPackages').mockResolvedValue({ key_packages: [] });
             jest.spyOn(mlsService, 'scheduleKeyMaterialRenewal').mockImplementation();
-            jest.spyOn(mlsService, 'processCommitAction').mockImplementation(() => ({
-                failed_to_send: [],
-                failed: [],
-                events: [],
-                time: '',
-            }));
             jest.spyOn(mlsService, 'cancelKeyMaterialRenewal').mockImplementation();
         });
         it('creates a new mls conversation and avoid adding the selfUser', async () => {
@@ -117,37 +156,10 @@ describe('MLSService', () => {
                 keyPackages: [],
                 failures: [failure],
             });
-            const { failures } = await mlsService.registerConversation(groupId, [...users, selfUser], { creator });
+            const failures = await mlsService.registerConversation(groupId, [...users, selfUser], { creator });
             expect(failures).toEqual([failure]);
             expect(mlsService.scheduleKeyMaterialRenewal).toHaveBeenCalledWith(groupId);
         });
-        it("returns a list of failure reasons if it was not possible to upload users' keys", async () => {
-            const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
-            const selfUser = createUserId();
-            const creator = { user: selfUser, client: 'client-1' };
-            const users = [createUserId(), createUserId()];
-            const failureKeysClaiming = {
-                reason: conversation_1.AddUsersFailureReasons.OFFLINE_FOR_TOO_LONG,
-                users: [users[0]],
-            };
-            const failureKeysUpload = {
-                reason: conversation_1.AddUsersFailureReasons.UNREACHABLE_BACKENDS,
-                users: [users[1]],
-                backends: [users[1].domain],
-            };
-            jest.spyOn(mlsService, 'getKeyPackagesPayload').mockResolvedValueOnce({
-                keyPackages: [new Uint8Array()],
-                failures: [failureKeysClaiming],
-            });
-            jest.spyOn(mlsService, 'addUsersToExistingConversation').mockResolvedValueOnce({
-                failures: [failureKeysUpload],
-                events: [],
-                time: '',
-            });
-            const { failures } = await mlsService.registerConversation(groupId, [...users, selfUser], { creator });
-            expect(failures).toEqual([failureKeysClaiming, failureKeysUpload]);
-            expect(mlsService.scheduleKeyMaterialRenewal).toHaveBeenCalledWith(groupId);
-        });
     });
     describe('getKeyPackagesPayload', () => {
         it('succesfully claims keys for all users', async () => {
@@ -182,24 +194,24 @@ describe('MLSService', () => {
     });
     describe('isConversationEstablished', () => {
         it('returns false if conversation does not exist locally', async () => {
-            const [mlsService] = await createMLSService();
+            const [mlsService, { coreCrypto }] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(false);
+            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(false);
             const isEstablshed = await mlsService.isConversationEstablished(groupId);
             expect(isEstablshed).toBe(false);
         });
         it('returns false if epoch number is 0', async () => {
-            const [mlsService] = await createMLSService();
+            const [mlsService, { coreCrypto }] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
+            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(true);
             jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(0);
             const isEstablshed = await mlsService.isConversationEstablished(groupId);
             expect(isEstablshed).toBe(false);
         });
         it.each([1, 2, 100])('returns false if epoch number is 1 or more', async (epoch) => {
-            const [mlsService] = await createMLSService();
+            const [mlsService, { coreCrypto }] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
+            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(true);
             jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(epoch);
             const isEstablshed = await mlsService.isConversationEstablished(groupId);
             expect(isEstablshed).toBe(true);
@@ -269,7 +281,7 @@ describe('MLSService', () => {
     });
     describe('initClient', () => {
         it('uses the default config if config is not provided by the consumer', async () => {
-            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, coreCrypto, transactionContext }] = await createMLSService();
             const mockUserId = { id: 'user-1', domain: 'local.zinfra.io' };
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: {}, id: mockClientId };
@@ -280,11 +292,11 @@ describe('MLSService', () => {
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(mlsService.config.nbKeyPackages);
             const config = { ...defaultMLSInitConfig };
             await mlsService.initClient(mockUserId, mockClient, config);
-            expect(coreCrypto.mlsInit).toHaveBeenCalledWith(expect.any(Uint8Array), [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519], 100);
+            expect(transactionContext.mlsInit).toHaveBeenCalledWith(expect.any(core_crypto_1.ClientId), [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519], 100);
             expect(mlsService.config.nbKeyPackages).toEqual(100);
         });
         it('uses the config provided by the consumer', async () => {
-            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, transactionContext, coreCrypto }] = await createMLSService();
             const mockUserId = { id: 'user-1', domain: 'local.zinfra.io' };
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: {}, id: mockClientId };
@@ -295,11 +307,11 @@ describe('MLSService', () => {
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(mlsService.config.nbKeyPackages);
             const config = { ...defaultMLSInitConfig, nbKeyPackages: 40, keyingMaterialUpdateThreshold: TimeUtil_1.TimeInMillis.DAY };
             await mlsService.initClient(mockUserId, mockClient, config);
-            expect(coreCrypto.mlsInit).toHaveBeenCalledWith(expect.any(Uint8Array), [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519], config.nbKeyPackages);
+            expect(transactionContext.mlsInit).toHaveBeenCalledWith(expect.any(core_crypto_1.ClientId), [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519], config.nbKeyPackages);
             expect(mlsService.config).toEqual(config);
         });
         it('uses the default config value when provided with undefined by the consumer', async () => {
-            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, transactionContext, coreCrypto }] = await createMLSService();
             const mockUserId = { id: 'user-1', domain: 'local.zinfra.io' };
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: {}, id: mockClientId };
@@ -314,41 +326,43 @@ describe('MLSService', () => {
                 keyingMaterialUpdateThreshold: TimeUtil_1.TimeInMillis.DAY,
             };
             await mlsService.initClient(mockUserId, mockClient, config);
-            expect(coreCrypto.mlsInit).toHaveBeenCalledWith(expect.any(Uint8Array), [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519], 100);
+            expect(transactionContext.mlsInit).toHaveBeenCalledWith(expect.any(core_crypto_1.ClientId), [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519], 100);
             expect(mlsService.config).toEqual({ ...config, nbKeyPackages: 100 });
         });
         it('uploads public key only if it was not yet defined on client entity', async () => {
-            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, transactionContext, coreCrypto }] = await createMLSService();
             const mockUserId = { id: 'user-1', domain: 'local.zinfra.io' };
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: {}, id: mockClientId };
             apiClient.context = { clientType: client_1.ClientType.PERMANENT, clientId: mockClientId, userId: '' };
-            const mockedClientPublicKey = new Uint8Array();
-            jest.spyOn(coreCrypto, 'clientPublicKey').mockResolvedValueOnce(mockedClientPublicKey);
             jest.spyOn(apiClient.api.client, 'putClient').mockResolvedValueOnce(undefined);
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(mlsService.config.nbKeyPackages);
+            jest.spyOn(Helper, 'getMLSDeviceStatus').mockReturnValueOnce(Helper.MLSDeviceStatus.FRESH);
+            jest.spyOn(coreCrypto, 'clientPublicKey').mockResolvedValue(new Uint8Array());
             await mlsService.initClient(mockUserId, mockClient, defaultMLSInitConfig);
-            expect(coreCrypto.mlsInit).toHaveBeenCalled();
+            expect(transactionContext.mlsInit).toHaveBeenCalled();
             expect(apiClient.api.client.putClient).toHaveBeenCalledWith(mockClientId, expect.anything());
         });
         it('uploads key packages if there are not enough keys on backend', async () => {
-            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, transactionContext, coreCrypto }] = await createMLSService();
             const mockUserId = { id: 'user-1', domain: 'local.zinfra.io' };
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: { ed25519: 'key' }, id: mockClientId };
             apiClient.context = { clientType: client_1.ClientType.PERMANENT, clientId: mockClientId, userId: '' };
             const mockedClientKeyPackages = [new Uint8Array()];
-            jest.spyOn(coreCrypto, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
+            jest.spyOn(transactionContext, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
+            jest.spyOn(coreCrypto, 'clientPublicKey').mockResolvedValueOnce(new Uint8Array());
+            jest.spyOn(Helper, 'getMLSDeviceStatus').mockReturnValueOnce(Helper.MLSDeviceStatus.REGISTERED);
+            jest.spyOn(apiClient.api.client, 'uploadMLSKeyPackages').mockResolvedValueOnce(undefined);
             jest
                 .spyOn(apiClient.api.client, 'getMLSKeyPackageCount')
                 .mockResolvedValueOnce(mlsService['minRequiredKeyPackages'] - 1);
-            jest.spyOn(apiClient.api.client, 'uploadMLSKeyPackages').mockResolvedValueOnce(undefined);
             await mlsService.initClient(mockUserId, mockClient, defaultMLSInitConfig);
-            expect(coreCrypto.mlsInit).toHaveBeenCalled();
+            expect(transactionContext.mlsInit).toHaveBeenCalled();
             expect(apiClient.api.client.uploadMLSKeyPackages).toHaveBeenCalledWith(mockClientId, expect.anything());
         });
         it('does not upload public key or key packages if both are already uploaded', async () => {
-            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, transactionContext, coreCrypto }] = await createMLSService();
             const mockUserId = { id: 'user-1', domain: 'local.zinfra.io' };
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: { ed25519: 'key' }, id: mockClientId };
@@ -357,95 +371,64 @@ describe('MLSService', () => {
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(mlsService.config.nbKeyPackages);
             jest.spyOn(apiClient.api.client, 'uploadMLSKeyPackages');
             jest.spyOn(apiClient.api.client, 'putClient');
+            jest.spyOn(coreCrypto, 'clientPublicKey').mockResolvedValueOnce(new Uint8Array());
             await mlsService.initClient(mockUserId, mockClient, defaultMLSInitConfig);
-            expect(coreCrypto.mlsInit).toHaveBeenCalled();
+            expect(transactionContext.mlsInit).toHaveBeenCalled();
             expect(apiClient.api.client.uploadMLSKeyPackages).not.toHaveBeenCalled();
             expect(apiClient.api.client.putClient).not.toHaveBeenCalled();
         });
     });
     describe('wipeConversation', () => {
         it('wipes a group and cancels its timers', async () => {
-            const [mlsService, { coreCrypto, recurringTaskScheduler }] = await createMLSService();
+            const [mlsService, { recurringTaskScheduler, coreCrypto, transactionContext }] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm4OQFc=';
-            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(true);
+            coreCrypto.conversationExists = jest.fn().mockResolvedValue(true);
+            transactionContext.wipeConversation = jest.fn().mockResolvedValue(undefined);
             jest.spyOn(recurringTaskScheduler, 'cancelTask');
             jest.spyOn(TaskScheduler_1.TaskScheduler, 'cancelTask');
             await mlsService.wipeConversation(groupId);
             expect(recurringTaskScheduler.cancelTask).toHaveBeenCalledWith(expect.stringContaining(groupId));
             expect(TaskScheduler_1.TaskScheduler.cancelTask).toHaveBeenCalledWith(expect.stringContaining(groupId));
-            expect(coreCrypto.wipeConversation).toHaveBeenCalled();
+            expect(transactionContext.wipeConversation).toHaveBeenCalled();
         });
         it('does not try to wipe a group if it does not exist already', async () => {
-            const [mlsService, { coreCrypto, recurringTaskScheduler }] = await createMLSService();
+            const [mlsService, { recurringTaskScheduler, transactionContext, coreCrypto }] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm4OQFc=';
-            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(false);
+            coreCrypto.conversationExists = jest.fn().mockResolvedValue(false);
+            transactionContext.wipeConversation = jest.fn().mockResolvedValue(undefined);
             jest.spyOn(recurringTaskScheduler, 'cancelTask');
             jest.spyOn(TaskScheduler_1.TaskScheduler, 'cancelTask');
             await mlsService.wipeConversation(groupId);
             expect(recurringTaskScheduler.cancelTask).toHaveBeenCalledWith(expect.stringContaining(groupId));
             expect(TaskScheduler_1.TaskScheduler.cancelTask).toHaveBeenCalledWith(expect.stringContaining(groupId));
-            expect(coreCrypto.wipeConversation).not.toHaveBeenCalled();
-        });
-    });
-    describe('commitPendingProposals', () => {
-        it('commits pending proposals and uploads received commit bundle to backend', async () => {
-            const [mlsService, { coreCrypto: mockCoreCrypto, apiClient }] = await createMLSService();
-            const mockGroupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
-            jest.spyOn(mockCoreCrypto, 'commitPendingProposals').mockResolvedValueOnce({
-                commit: new Uint8Array(),
-                groupInfo: { payload: new Uint8Array() },
-            });
-            jest.spyOn(apiClient.api.conversation, 'postMlsCommitBundle').mockResolvedValueOnce({ events: [], time: '' });
-            await mlsService.commitPendingProposals(mockGroupId);
-            expect(mockCoreCrypto.commitPendingProposals).toHaveBeenCalled();
-            expect(apiClient.api.conversation.postMlsCommitBundle).toHaveBeenCalled();
-        });
-        it('clears pending commit and retries when failed committing pending proposals', async () => {
-            const [mlsService, { coreCrypto: mockCoreCrypto, apiClient }] = await createMLSService();
-            const mockGroupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
-            jest.spyOn(mockCoreCrypto, 'commitPendingProposals').mockRejectedValueOnce(new Error('mocked error'));
-            jest.spyOn(mockCoreCrypto, 'commitPendingProposals').mockResolvedValueOnce({
-                commit: new Uint8Array(),
-                groupInfo: { payload: new Uint8Array() },
-            });
-            jest.spyOn(apiClient.api.conversation, 'postMlsCommitBundle').mockResolvedValueOnce({ events: [], time: '' });
-            jest.spyOn(mockCoreCrypto, 'clearPendingCommit');
-            jest.spyOn(mockCoreCrypto, 'clearPendingGroupFromExternalCommit');
-            await mlsService.commitPendingProposals(mockGroupId);
-            expect(mockCoreCrypto.clearPendingCommit).toHaveBeenCalledTimes(1);
-            expect(mockCoreCrypto.clearPendingGroupFromExternalCommit).toHaveBeenCalledTimes(1);
-            expect(mockCoreCrypto.commitPendingProposals).toHaveBeenCalledTimes(2);
-            expect(apiClient.api.conversation.postMlsCommitBundle).toHaveBeenCalledTimes(1);
+            expect(transactionContext.wipeConversation).not.toHaveBeenCalled();
         });
     });
     describe('handleMLSMessageAddEvent', () => {
-        it('decrypts a message and emits new epoch event if epoch has changed', async () => {
-            const [mlsService, { coreCrypto: mockCoreCrypto }] = await createMLSService();
+        it('decrypts a message', async () => {
+            const [mlsService, { transactionContext, coreCrypto }] = await createMLSService();
             const mockGroupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
             const mockedNewEpoch = 3;
             const getGroupIdFromConversationId = () => Promise.resolve(mockGroupId);
             const mockedDecryptoedMessage = {
                 hasEpochChanged: true,
                 isActive: false,
-                proposals: [],
             };
-            jest.spyOn(mockCoreCrypto, 'transaction').mockResolvedValueOnce(mockedDecryptoedMessage);
-            jest.spyOn(mockCoreCrypto, 'conversationEpoch').mockResolvedValueOnce(mockedNewEpoch);
-            jest.spyOn(mlsService, 'emit').mockImplementation(jest.fn());
+            jest.spyOn(transactionContext, 'decryptMessage').mockResolvedValueOnce(mockedDecryptoedMessage);
+            jest.spyOn(coreCrypto, 'conversationEpoch').mockResolvedValueOnce(mockedNewEpoch);
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_MESSAGE_ADD,
                 senderClientId: '',
                 conversation: '',
-                data: '',
+                data: mockedMLSWelcomeEventData,
                 from: '',
                 time: '',
             };
             await mlsService.handleMLSMessageAddEvent(mockedMLSWelcomeEvent, getGroupIdFromConversationId);
-            expect(mockCoreCrypto.transaction).toHaveBeenCalled();
-            expect(mlsService.emit).toHaveBeenCalledWith('newEpoch', { epoch: mockedNewEpoch, groupId: mockGroupId });
+            expect(transactionContext.decryptMessage).toHaveBeenCalled();
         });
         it('handles pending propoals with a delay after decrypting a message', async () => {
-            const [mlsService, { coreCrypto: mockCoreCrypto }] = await createMLSService();
+            const [mlsService, { transactionContext, coreCrypto }] = await createMLSService();
             jest.useFakeTimers();
             const mockGroupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
             const mockedNewEpoch = 3;
@@ -454,122 +437,138 @@ describe('MLSService', () => {
             const mockedDecryptoedMessage = {
                 hasEpochChanged: true,
                 isActive: false,
-                proposals: [],
                 commitDelay,
             };
-            jest.spyOn(mockCoreCrypto, 'transaction').mockResolvedValueOnce(mockedDecryptoedMessage);
-            jest.spyOn(mockCoreCrypto, 'conversationEpoch').mockResolvedValueOnce(mockedNewEpoch);
+            jest.spyOn(transactionContext, 'decryptMessage').mockResolvedValueOnce(mockedDecryptoedMessage);
+            jest.spyOn(coreCrypto, 'conversationEpoch').mockResolvedValueOnce(mockedNewEpoch);
             jest.spyOn(mlsService, 'commitPendingProposals');
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_MESSAGE_ADD,
                 senderClientId: '',
                 conversation: '',
-                data: '',
+                data: mockedMLSWelcomeEventData,
                 from: '',
                 time: new Date().toISOString(),
             };
             await mlsService.handleMLSMessageAddEvent(mockedMLSWelcomeEvent, getGroupIdFromConversationId);
-            expect(mockCoreCrypto.commitPendingProposals).not.toHaveBeenCalled();
             jest.advanceTimersByTime(commitDelay);
-            expect(mockCoreCrypto.transaction).toHaveBeenCalled();
-            expect(mockCoreCrypto.commitPendingProposals).toHaveBeenCalled();
+            expect(transactionContext.decryptMessage).toHaveBeenCalled();
+        });
+        it('Throws if decryption fails', async () => {
+            const [mlsService, { transactionContext }] = await createMLSService();
+            const mockGroupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
+            const getGroupIdFromConversationId = () => Promise.resolve(mockGroupId);
+            jest
+                .spyOn(transactionContext, 'decryptMessage')
+                .mockRejectedValueOnce(new Error(CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorWrongEpoch));
+            const mockedMLSMessageAddEvent = {
+                type: event_1.CONVERSATION_EVENT.MLS_MESSAGE_ADD,
+                senderClientId: '',
+                conversation: '',
+                data: mockedMLSWelcomeEventData,
+                from: '',
+                time: '',
+            };
+            await expect(mlsService.handleMLSMessageAddEvent(mockedMLSMessageAddEvent, getGroupIdFromConversationId)).rejects.toThrow(CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorWrongEpoch);
+            expect(transactionContext.decryptMessage).toHaveBeenCalled();
         });
     });
     describe('handleMLSWelcomeMessageEvent', () => {
         it("before processing welcome it verifies that there's enough key packages locally", async () => {
-            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, transactionContext }] = await createMLSService();
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: { ed25519: 'key' }, id: mockClientId };
             apiClient.context = { clientType: client_1.ClientType.PERMANENT, clientId: mockClientId, userId: '' };
             const mockedClientKeyPackages = [new Uint8Array()];
-            jest.spyOn(coreCrypto, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
+            jest.spyOn(transactionContext, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
             const numberOfKeysBelowThreshold = mlsService['minRequiredKeyPackages'] - 1;
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(numberOfKeysBelowThreshold);
-            jest.spyOn(coreCrypto, 'clientValidKeypackagesCount').mockResolvedValueOnce(numberOfKeysBelowThreshold);
+            jest.spyOn(transactionContext, 'clientValidKeypackagesCount').mockResolvedValue(numberOfKeysBelowThreshold);
             jest.spyOn(apiClient.api.client, 'uploadMLSKeyPackages').mockResolvedValueOnce(undefined);
-            jest
-                .spyOn(coreCrypto, 'processWelcomeMessage')
-                .mockResolvedValueOnce({ id: new Uint8Array(), crlNewDistributionPoints: [] });
+            jest.spyOn(transactionContext, 'processWelcomeMessage').mockResolvedValue({
+                id: new core_crypto_1.ConversationId(new Uint8Array()),
+                crlNewDistributionPoints: [],
+            });
             jest.spyOn(mlsService, 'scheduleKeyMaterialRenewal').mockImplementation(jest.fn());
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_WELCOME_MESSAGE,
                 conversation: '',
-                data: '',
+                data: mockedMLSWelcomeEventData,
                 from: '',
                 time: '',
             };
             await mlsService.handleMLSWelcomeMessageEvent(mockedMLSWelcomeEvent, mockClient.id);
-            expect(coreCrypto.processWelcomeMessage).toHaveBeenCalled();
+            expect(transactionContext.processWelcomeMessage).toHaveBeenCalled();
             expect(apiClient.api.client.uploadMLSKeyPackages).toHaveBeenCalledWith(mockClientId, expect.anything());
         });
         it('before processing welcome it does not generate new keys if there is enough key packages locally', async () => {
-            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, transactionContext }] = await createMLSService();
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: { ed25519: 'key' }, id: mockClientId };
             apiClient.context = { clientType: client_1.ClientType.PERMANENT, clientId: mockClientId, userId: '' };
             const mockedClientKeyPackages = [new Uint8Array()];
-            jest.spyOn(coreCrypto, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
+            jest.spyOn(transactionContext, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
             const numberOfKeysAboveThreshold = mlsService['minRequiredKeyPackages'] + 1;
-            jest.spyOn(coreCrypto, 'clientValidKeypackagesCount').mockResolvedValueOnce(numberOfKeysAboveThreshold);
+            jest.spyOn(transactionContext, 'clientValidKeypackagesCount').mockResolvedValue(numberOfKeysAboveThreshold);
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(numberOfKeysAboveThreshold);
             jest.spyOn(apiClient.api.client, 'uploadMLSKeyPackages').mockResolvedValueOnce(undefined);
-            jest
-                .spyOn(coreCrypto, 'processWelcomeMessage')
-                .mockResolvedValueOnce({ id: new Uint8Array(), crlNewDistributionPoints: [] });
+            jest.spyOn(transactionContext, 'processWelcomeMessage').mockResolvedValue({
+                id: new core_crypto_1.ConversationId(new Uint8Array()),
+                crlNewDistributionPoints: [],
+            });
             jest.spyOn(mlsService, 'scheduleKeyMaterialRenewal').mockImplementation(jest.fn());
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_WELCOME_MESSAGE,
                 conversation: '',
-                data: '',
+                data: mockedMLSWelcomeEventData,
                 from: '',
                 time: '',
             };
             await mlsService.handleMLSWelcomeMessageEvent(mockedMLSWelcomeEvent, mockClient.id);
-            expect(coreCrypto.processWelcomeMessage).toHaveBeenCalled();
+            expect(transactionContext.processWelcomeMessage).toHaveBeenCalled();
             expect(apiClient.api.client.uploadMLSKeyPackages).not.toHaveBeenCalled();
         });
         it('before processing welcome it does not generate new keys if there is enough key packages uploaded to backend', async () => {
-            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, transactionContext }] = await createMLSService();
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: { ed25519: 'key' }, id: mockClientId };
             apiClient.context = { clientType: client_1.ClientType.PERMANENT, clientId: mockClientId, userId: '' };
             const mockedClientKeyPackages = [new Uint8Array()];
-            jest.spyOn(coreCrypto, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
+            jest.spyOn(transactionContext, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
             const numberOfKeysBelowThreshold = mlsService['minRequiredKeyPackages'] - 1;
             const numberOfKeysAboveThreshold = mlsService['minRequiredKeyPackages'] + 1;
-            jest.spyOn(coreCrypto, 'clientValidKeypackagesCount').mockResolvedValueOnce(numberOfKeysBelowThreshold);
+            jest.spyOn(transactionContext, 'clientValidKeypackagesCount').mockResolvedValue(numberOfKeysBelowThreshold);
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(numberOfKeysAboveThreshold);
             jest.spyOn(apiClient.api.client, 'uploadMLSKeyPackages').mockResolvedValueOnce(undefined);
-            jest
-                .spyOn(coreCrypto, 'processWelcomeMessage')
-                .mockResolvedValueOnce({ id: new Uint8Array(), crlNewDistributionPoints: [] });
+            jest.spyOn(transactionContext, 'processWelcomeMessage').mockResolvedValue({
+                id: new core_crypto_1.ConversationId(new Uint8Array()),
+                crlNewDistributionPoints: [],
+            });
             jest.spyOn(mlsService, 'scheduleKeyMaterialRenewal').mockImplementation(jest.fn());
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_WELCOME_MESSAGE,
                 conversation: '',
-                data: '',
+                data: mockedMLSWelcomeEventData,
                 from: '',
                 time: '',
             };
             await mlsService.handleMLSWelcomeMessageEvent(mockedMLSWelcomeEvent, mockClient.id);
-            expect(coreCrypto.processWelcomeMessage).toHaveBeenCalled();
+            expect(transactionContext.processWelcomeMessage).toHaveBeenCalled();
             expect(apiClient.api.client.uploadMLSKeyPackages).not.toHaveBeenCalled();
         });
     });
     describe('tryEstablishingMLSGroup', () => {
         it('returns false if group did already exist locally', async () => {
-            const [mlsService] = await createMLSService();
-            const mockGroupId = 'mock-group-id';
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
+            const [mlsService, { coreCrypto }] = await createMLSService();
+            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(true);
             jest.spyOn(mlsService, 'registerConversation').mockImplementation(jest.fn());
             const wasConversationEstablished = await mlsService.tryEstablishingMLSGroup(mockGroupId);
             expect(mlsService.registerConversation).not.toHaveBeenCalled();
             expect(wasConversationEstablished).toBe(false);
         });
         it('returns false if corecrypto has thrown an error when trying to register group locally', async () => {
-            const [mlsService] = await createMLSService();
-            const mockGroupId = 'mock-group-id';
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(false);
+            const [mlsService, { coreCrypto }] = await createMLSService();
+            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(false);
             const conversationAlreadyExistsError = new Error();
             conversationAlreadyExistsError.name = CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorConversationAlreadyExists;
             jest.spyOn(mlsService, 'registerConversation').mockRejectedValueOnce(conversationAlreadyExistsError);
@@ -578,9 +577,8 @@ describe('MLSService', () => {
             expect(wasConversationEstablished).toBe(false);
         });
         it('returns false and wipes group locally if any backend error was thrown', async () => {
-            const [mlsService] = await createMLSService();
-            const mockGroupId = 'mock-group-id2';
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(false);
+            const [mlsService, { transactionContext }] = await createMLSService();
+            jest.spyOn(transactionContext, 'conversationExists').mockResolvedValueOnce(false);
             jest
                 .spyOn(mlsService, 'registerConversation')
                 .mockRejectedValueOnce(new http_1.BackendError('', http_1.BackendErrorLabel.MLS_STALE_MESSAGE, http_1.StatusCode.CONFLICT));
@@ -591,10 +589,9 @@ describe('MLSService', () => {
             expect(wasConversationEstablished).toBe(false);
         });
         it('returns true after MLS group was etablished successfully', async () => {
-            const [mlsService] = await createMLSService();
-            const mockGroupId = 'mock-group-id2';
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(false);
-            jest.spyOn(mlsService, 'registerConversation').mockResolvedValueOnce({ events: [], time: '', failures: [] });
+            const [mlsService, { transactionContext }] = await createMLSService();
+            jest.spyOn(transactionContext, 'conversationExists').mockResolvedValueOnce(false);
+            jest.spyOn(mlsService, 'registerConversation').mockResolvedValueOnce([]);
             jest.spyOn(mlsService, 'wipeConversation').mockImplementation(jest.fn());
             const wasConversationEstablished = await mlsService.tryEstablishingMLSGroup(mockGroupId);
             expect(mlsService.registerConversation).toHaveBeenCalledWith(mockGroupId, []);

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

@@ -19,7 +19,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toProtobufCommitBundle = toProtobufCommitBundle;
-const mls_1 = require("@pydio/protocol-messaging/web/mls");
+const mls_1 = require("@wireapp/protocol-messaging/web/mls");
 const core_crypto_1 = require("@wireapp/core-crypto");
 const ratchetTreeMapping = {
     [core_crypto_1.RatchetTreeType.Full]: mls_1.mls.RatchetTreeType.FULL,
@@ -40,10 +40,10 @@ function toProtobufCommitBundle({ commit, welcome, groupInfo }) {
     return mls_1.mls.CommitBundle.encode({
         groupInfoBundle: {
             ratchetTreeType: ratchetTreeMapping[ratchetTreeType],
-            groupInfo: groupInfo.payload,
+            groupInfo: groupInfo.payload.copyBytes(),
             groupInfoType: groupInfoType[encryptionType],
         },
         commit,
-        welcome,
+        welcome: welcome?.copyBytes(),
     }).finish();
 }