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

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

@@ -17,29 +17,6 @@
  * 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");
@@ -54,11 +31,6 @@ 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: '' };
@@ -67,36 +39,25 @@ 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();
-    apiClients.push(apiClient);
-    const transactionContext = {
-        mlsInit: jest.fn(),
-        wipeConversation: jest.fn(),
-        clientKeypackages: jest.fn(),
+    const mockCoreCrypto = {
         createConversation: jest.fn(),
-        clientValidKeypackagesCount: jest.fn(),
         conversationExists: jest.fn(),
+        wipeConversation: jest.fn(),
+        clientValidKeypackagesCount: jest.fn(),
+        clientKeypackages: jest.fn(),
+        mlsInit: jest.fn(),
+        clientPublicKey: jest.fn(),
         processWelcomeMessage: jest.fn(),
+        conversationEpoch: jest.fn(),
         commitPendingProposals: 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(),
+        registerCallbacks: jest.fn(),
         e2eiIsEnabled: jest.fn(() => false),
-        clientPublicKey: jest.fn(),
-        conversationEpoch: jest.fn(),
+        clearPendingGroupFromExternalCommit: async () => { },
+        clearPendingCommit: async () => { },
+        commitAccepted: jest.fn(),
+        transaction: jest.fn(),
     };
     const mockedDb = await (0, CoreDB_1.openDB)('core-test-db');
     const recurringTaskScheduler = new RecurringTaskScheduler_1.RecurringTaskScheduler({
@@ -108,15 +69,9 @@ 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, transactionContext }];
+    return [mlsService, { apiClient, coreCrypto: mockCoreCrypto, recurringTaskScheduler }];
 };
-afterAll(() => {
-    jest.clearAllTimers();
-});
 describe('MLSService', () => {
-    afterAll(() => {
-        apiClients.forEach(client => client.disconnect());
-    });
     describe('registerConversation', () => {
         let mlsService;
         let apiClient;
@@ -129,6 +84,12 @@ 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 () => {
@@ -156,10 +117,37 @@ 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 () => {
@@ -194,24 +182,24 @@ describe('MLSService', () => {
     });
     describe('isConversationEstablished', () => {
         it('returns false if conversation does not exist locally', async () => {
-            const [mlsService, { coreCrypto }] = await createMLSService();
+            const [mlsService] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
-            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(false);
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(false);
             const isEstablshed = await mlsService.isConversationEstablished(groupId);
             expect(isEstablshed).toBe(false);
         });
         it('returns false if epoch number is 0', async () => {
-            const [mlsService, { coreCrypto }] = await createMLSService();
+            const [mlsService] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
-            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(true);
+            jest.spyOn(mlsService, '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, { coreCrypto }] = await createMLSService();
+            const [mlsService] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
-            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(true);
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
             jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(epoch);
             const isEstablshed = await mlsService.isConversationEstablished(groupId);
             expect(isEstablshed).toBe(true);
@@ -281,7 +269,7 @@ describe('MLSService', () => {
     });
     describe('initClient', () => {
         it('uses the default config if config is not provided by the consumer', async () => {
-            const [mlsService, { apiClient, coreCrypto, transactionContext }] = await createMLSService();
+            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
             const mockUserId = { id: 'user-1', domain: 'local.zinfra.io' };
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: {}, id: mockClientId };
@@ -292,11 +280,11 @@ describe('MLSService', () => {
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(mlsService.config.nbKeyPackages);
             const config = { ...defaultMLSInitConfig };
             await mlsService.initClient(mockUserId, mockClient, config);
-            expect(transactionContext.mlsInit).toHaveBeenCalledWith(expect.any(core_crypto_1.ClientId), [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519], 100);
+            expect(coreCrypto.mlsInit).toHaveBeenCalledWith(expect.any(Uint8Array), [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, transactionContext, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
             const mockUserId = { id: 'user-1', domain: 'local.zinfra.io' };
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: {}, id: mockClientId };
@@ -307,11 +295,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(transactionContext.mlsInit).toHaveBeenCalledWith(expect.any(core_crypto_1.ClientId), [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519], config.nbKeyPackages);
+            expect(coreCrypto.mlsInit).toHaveBeenCalledWith(expect.any(Uint8Array), [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, transactionContext, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, coreCrypto }] = await createMLSService();
             const mockUserId = { id: 'user-1', domain: 'local.zinfra.io' };
             const mockClientId = 'client-1';
             const mockClient = { mls_public_keys: {}, id: mockClientId };
@@ -326,43 +314,41 @@ describe('MLSService', () => {
                 keyingMaterialUpdateThreshold: TimeUtil_1.TimeInMillis.DAY,
             };
             await mlsService.initClient(mockUserId, mockClient, config);
-            expect(transactionContext.mlsInit).toHaveBeenCalledWith(expect.any(core_crypto_1.ClientId), [core_crypto_1.Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519], 100);
+            expect(coreCrypto.mlsInit).toHaveBeenCalledWith(expect.any(Uint8Array), [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, transactionContext, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, 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(transactionContext.mlsInit).toHaveBeenCalled();
+            expect(coreCrypto.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, transactionContext, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, 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(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(coreCrypto, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
             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(transactionContext.mlsInit).toHaveBeenCalled();
+            expect(coreCrypto.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, transactionContext, coreCrypto }] = await createMLSService();
+            const [mlsService, { apiClient, 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 };
@@ -371,64 +357,95 @@ 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(transactionContext.mlsInit).toHaveBeenCalled();
+            expect(coreCrypto.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, { recurringTaskScheduler, coreCrypto, transactionContext }] = await createMLSService();
+            const [mlsService, { coreCrypto, recurringTaskScheduler }] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm4OQFc=';
-            coreCrypto.conversationExists = jest.fn().mockResolvedValue(true);
-            transactionContext.wipeConversation = jest.fn().mockResolvedValue(undefined);
+            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(true);
             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(transactionContext.wipeConversation).toHaveBeenCalled();
+            expect(coreCrypto.wipeConversation).toHaveBeenCalled();
         });
         it('does not try to wipe a group if it does not exist already', async () => {
-            const [mlsService, { recurringTaskScheduler, transactionContext, coreCrypto }] = await createMLSService();
+            const [mlsService, { coreCrypto, recurringTaskScheduler }] = await createMLSService();
             const groupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm4OQFc=';
-            coreCrypto.conversationExists = jest.fn().mockResolvedValue(false);
-            transactionContext.wipeConversation = jest.fn().mockResolvedValue(undefined);
+            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(false);
             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(transactionContext.wipeConversation).not.toHaveBeenCalled();
+            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);
         });
     });
     describe('handleMLSMessageAddEvent', () => {
-        it('decrypts a message', async () => {
-            const [mlsService, { transactionContext, coreCrypto }] = await createMLSService();
+        it('decrypts a message and emits new epoch event if epoch has changed', async () => {
+            const [mlsService, { coreCrypto: mockCoreCrypto }] = 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(transactionContext, 'decryptMessage').mockResolvedValueOnce(mockedDecryptoedMessage);
-            jest.spyOn(coreCrypto, 'conversationEpoch').mockResolvedValueOnce(mockedNewEpoch);
+            jest.spyOn(mockCoreCrypto, 'transaction').mockResolvedValueOnce(mockedDecryptoedMessage);
+            jest.spyOn(mockCoreCrypto, 'conversationEpoch').mockResolvedValueOnce(mockedNewEpoch);
+            jest.spyOn(mlsService, 'emit').mockImplementation(jest.fn());
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_MESSAGE_ADD,
                 senderClientId: '',
                 conversation: '',
-                data: mockedMLSWelcomeEventData,
+                data: '',
                 from: '',
                 time: '',
             };
             await mlsService.handleMLSMessageAddEvent(mockedMLSWelcomeEvent, getGroupIdFromConversationId);
-            expect(transactionContext.decryptMessage).toHaveBeenCalled();
+            expect(mockCoreCrypto.transaction).toHaveBeenCalled();
+            expect(mlsService.emit).toHaveBeenCalledWith('newEpoch', { epoch: mockedNewEpoch, groupId: mockGroupId });
         });
         it('handles pending propoals with a delay after decrypting a message', async () => {
-            const [mlsService, { transactionContext, coreCrypto }] = await createMLSService();
+            const [mlsService, { coreCrypto: mockCoreCrypto }] = await createMLSService();
             jest.useFakeTimers();
             const mockGroupId = 'mXOagqRIX/RFd7QyXJA8/Ed8X+hvQgLXIiwYHm3OQFc=';
             const mockedNewEpoch = 3;
@@ -437,138 +454,122 @@ describe('MLSService', () => {
             const mockedDecryptoedMessage = {
                 hasEpochChanged: true,
                 isActive: false,
+                proposals: [],
                 commitDelay,
             };
-            jest.spyOn(transactionContext, 'decryptMessage').mockResolvedValueOnce(mockedDecryptoedMessage);
-            jest.spyOn(coreCrypto, 'conversationEpoch').mockResolvedValueOnce(mockedNewEpoch);
+            jest.spyOn(mockCoreCrypto, 'transaction').mockResolvedValueOnce(mockedDecryptoedMessage);
+            jest.spyOn(mockCoreCrypto, 'conversationEpoch').mockResolvedValueOnce(mockedNewEpoch);
             jest.spyOn(mlsService, 'commitPendingProposals');
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_MESSAGE_ADD,
                 senderClientId: '',
                 conversation: '',
-                data: mockedMLSWelcomeEventData,
+                data: '',
                 from: '',
                 time: new Date().toISOString(),
             };
             await mlsService.handleMLSMessageAddEvent(mockedMLSWelcomeEvent, getGroupIdFromConversationId);
+            expect(mockCoreCrypto.commitPendingProposals).not.toHaveBeenCalled();
             jest.advanceTimersByTime(commitDelay);
-            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();
+            expect(mockCoreCrypto.transaction).toHaveBeenCalled();
+            expect(mockCoreCrypto.commitPendingProposals).toHaveBeenCalled();
         });
     });
     describe('handleMLSWelcomeMessageEvent', () => {
         it("before processing welcome it verifies that there's enough key packages locally", async () => {
-            const [mlsService, { apiClient, transactionContext }] = await createMLSService();
+            const [mlsService, { apiClient, coreCrypto }] = 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(transactionContext, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
+            jest.spyOn(coreCrypto, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
             const numberOfKeysBelowThreshold = mlsService['minRequiredKeyPackages'] - 1;
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(numberOfKeysBelowThreshold);
-            jest.spyOn(transactionContext, 'clientValidKeypackagesCount').mockResolvedValue(numberOfKeysBelowThreshold);
+            jest.spyOn(coreCrypto, 'clientValidKeypackagesCount').mockResolvedValueOnce(numberOfKeysBelowThreshold);
             jest.spyOn(apiClient.api.client, 'uploadMLSKeyPackages').mockResolvedValueOnce(undefined);
-            jest.spyOn(transactionContext, 'processWelcomeMessage').mockResolvedValue({
-                id: new core_crypto_1.ConversationId(new Uint8Array()),
-                crlNewDistributionPoints: [],
-            });
+            jest
+                .spyOn(coreCrypto, 'processWelcomeMessage')
+                .mockResolvedValueOnce({ id: new Uint8Array(), crlNewDistributionPoints: [] });
             jest.spyOn(mlsService, 'scheduleKeyMaterialRenewal').mockImplementation(jest.fn());
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_WELCOME_MESSAGE,
                 conversation: '',
-                data: mockedMLSWelcomeEventData,
+                data: '',
                 from: '',
                 time: '',
             };
             await mlsService.handleMLSWelcomeMessageEvent(mockedMLSWelcomeEvent, mockClient.id);
-            expect(transactionContext.processWelcomeMessage).toHaveBeenCalled();
+            expect(coreCrypto.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, transactionContext }] = await createMLSService();
+            const [mlsService, { apiClient, coreCrypto }] = 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(transactionContext, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
+            jest.spyOn(coreCrypto, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
             const numberOfKeysAboveThreshold = mlsService['minRequiredKeyPackages'] + 1;
-            jest.spyOn(transactionContext, 'clientValidKeypackagesCount').mockResolvedValue(numberOfKeysAboveThreshold);
+            jest.spyOn(coreCrypto, 'clientValidKeypackagesCount').mockResolvedValueOnce(numberOfKeysAboveThreshold);
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(numberOfKeysAboveThreshold);
             jest.spyOn(apiClient.api.client, 'uploadMLSKeyPackages').mockResolvedValueOnce(undefined);
-            jest.spyOn(transactionContext, 'processWelcomeMessage').mockResolvedValue({
-                id: new core_crypto_1.ConversationId(new Uint8Array()),
-                crlNewDistributionPoints: [],
-            });
+            jest
+                .spyOn(coreCrypto, 'processWelcomeMessage')
+                .mockResolvedValueOnce({ id: new Uint8Array(), crlNewDistributionPoints: [] });
             jest.spyOn(mlsService, 'scheduleKeyMaterialRenewal').mockImplementation(jest.fn());
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_WELCOME_MESSAGE,
                 conversation: '',
-                data: mockedMLSWelcomeEventData,
+                data: '',
                 from: '',
                 time: '',
             };
             await mlsService.handleMLSWelcomeMessageEvent(mockedMLSWelcomeEvent, mockClient.id);
-            expect(transactionContext.processWelcomeMessage).toHaveBeenCalled();
+            expect(coreCrypto.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, transactionContext }] = await createMLSService();
+            const [mlsService, { apiClient, coreCrypto }] = 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(transactionContext, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
+            jest.spyOn(coreCrypto, 'clientKeypackages').mockResolvedValueOnce(mockedClientKeyPackages);
             const numberOfKeysBelowThreshold = mlsService['minRequiredKeyPackages'] - 1;
             const numberOfKeysAboveThreshold = mlsService['minRequiredKeyPackages'] + 1;
-            jest.spyOn(transactionContext, 'clientValidKeypackagesCount').mockResolvedValue(numberOfKeysBelowThreshold);
+            jest.spyOn(coreCrypto, 'clientValidKeypackagesCount').mockResolvedValueOnce(numberOfKeysBelowThreshold);
             jest.spyOn(apiClient.api.client, 'getMLSKeyPackageCount').mockResolvedValueOnce(numberOfKeysAboveThreshold);
             jest.spyOn(apiClient.api.client, 'uploadMLSKeyPackages').mockResolvedValueOnce(undefined);
-            jest.spyOn(transactionContext, 'processWelcomeMessage').mockResolvedValue({
-                id: new core_crypto_1.ConversationId(new Uint8Array()),
-                crlNewDistributionPoints: [],
-            });
+            jest
+                .spyOn(coreCrypto, 'processWelcomeMessage')
+                .mockResolvedValueOnce({ id: new Uint8Array(), crlNewDistributionPoints: [] });
             jest.spyOn(mlsService, 'scheduleKeyMaterialRenewal').mockImplementation(jest.fn());
             const mockedMLSWelcomeEvent = {
                 type: event_1.CONVERSATION_EVENT.MLS_WELCOME_MESSAGE,
                 conversation: '',
-                data: mockedMLSWelcomeEventData,
+                data: '',
                 from: '',
                 time: '',
             };
             await mlsService.handleMLSWelcomeMessageEvent(mockedMLSWelcomeEvent, mockClient.id);
-            expect(transactionContext.processWelcomeMessage).toHaveBeenCalled();
+            expect(coreCrypto.processWelcomeMessage).toHaveBeenCalled();
             expect(apiClient.api.client.uploadMLSKeyPackages).not.toHaveBeenCalled();
         });
     });
     describe('tryEstablishingMLSGroup', () => {
         it('returns false if group did already exist locally', async () => {
-            const [mlsService, { coreCrypto }] = await createMLSService();
-            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(true);
+            const [mlsService] = await createMLSService();
+            const mockGroupId = 'mock-group-id';
+            jest.spyOn(mlsService, '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, { coreCrypto }] = await createMLSService();
-            jest.spyOn(coreCrypto, 'conversationExists').mockResolvedValueOnce(false);
+            const [mlsService] = await createMLSService();
+            const mockGroupId = 'mock-group-id';
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(false);
             const conversationAlreadyExistsError = new Error();
             conversationAlreadyExistsError.name = CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorConversationAlreadyExists;
             jest.spyOn(mlsService, 'registerConversation').mockRejectedValueOnce(conversationAlreadyExistsError);
@@ -577,8 +578,9 @@ describe('MLSService', () => {
             expect(wasConversationEstablished).toBe(false);
         });
         it('returns false and wipes group locally if any backend error was thrown', async () => {
-            const [mlsService, { transactionContext }] = await createMLSService();
-            jest.spyOn(transactionContext, 'conversationExists').mockResolvedValueOnce(false);
+            const [mlsService] = await createMLSService();
+            const mockGroupId = 'mock-group-id2';
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(false);
             jest
                 .spyOn(mlsService, 'registerConversation')
                 .mockRejectedValueOnce(new http_1.BackendError('', http_1.BackendErrorLabel.MLS_STALE_MESSAGE, http_1.StatusCode.CONFLICT));
@@ -589,9 +591,10 @@ describe('MLSService', () => {
             expect(wasConversationEstablished).toBe(false);
         });
         it('returns true after MLS group was etablished successfully', async () => {
-            const [mlsService, { transactionContext }] = await createMLSService();
-            jest.spyOn(transactionContext, 'conversationExists').mockResolvedValueOnce(false);
-            jest.spyOn(mlsService, 'registerConversation').mockResolvedValueOnce([]);
+            const [mlsService] = await createMLSService();
+            const mockGroupId = 'mock-group-id2';
+            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(false);
+            jest.spyOn(mlsService, 'registerConversation').mockResolvedValueOnce({ events: [], time: '', failures: [] });
             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("@wireapp/protocol-messaging/web/mls");
+const mls_1 = require("@pydio/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.copyBytes(),
+            groupInfo: groupInfo.payload,
             groupInfoType: groupInfoType[encryptionType],
         },
         commit,
-        welcome: welcome?.copyBytes(),
+        welcome,
     }).finish();
 }