@wireapp/core 46.24.0 → 46.24.2

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

@@ -67,34 +67,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 createMLSService = async () => {
     const apiClient = new api_client_1.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({
@@ -106,11 +97,8 @@ 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', () => {
     describe('registerConversation', () => {
         let mlsService;
@@ -124,6 +112,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 () => {
@@ -151,10 +145,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 () => {
@@ -189,24 +210,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);
@@ -276,7 +297,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 };
@@ -287,11 +308,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(Uint8Array), [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 };
@@ -302,11 +323,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(Uint8Array), [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 };
@@ -321,11 +342,11 @@ describe('MLSService', () => {
                 keyingMaterialUpdateThreshold: TimeUtil_1.TimeInMillis.DAY,
             };
             await mlsService.initClient(mockUserId, mockClient, config);
-            expect(transactionContext.mlsInit).toHaveBeenCalledWith(expect.any(Uint8Array), [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 };
@@ -335,17 +356,17 @@ describe('MLSService', () => {
             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, '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);
@@ -353,11 +374,11 @@ describe('MLSService', () => {
                 .spyOn(apiClient.api.client, 'getMLSKeyPackageCount')
                 .mockResolvedValueOnce(mlsService['minRequiredKeyPackages'] - 1);
             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 };
@@ -368,67 +389,97 @@ describe('MLSService', () => {
             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 and emits new epoch event if epoch has changed', async () => {
-            const [mlsService, { transactionContext, coreCrypto }] = await createMLSService();
+            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(MLSService_1.MLSServiceEvents.NEW_EPOCH, {
                 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,117 +488,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();
+            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 Uint8Array(), crlNewDistributionPoints: [] });
+                .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 Uint8Array(), crlNewDistributionPoints: [] });
+                .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 Uint8Array(), crlNewDistributionPoints: [] });
+                .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);
@@ -556,8 +612,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));
@@ -568,9 +625,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/types.d.ts

@@ -20,4 +20,12 @@ export type HandlePendingProposalsParams = {
     delayInMs: number;
     eventTime: string;
 } & CommonMLS;
+export interface CoreCryptoConfig {
+    /**
+     * path on the public server to the core crypto wasm file.
+     * This file will be downloaded lazily when corecrypto is needed.
+     * It, thus, needs to know where, on the server, the file can be found
+     */
+    wasmFilePath: string;
+}
 //# sourceMappingURL=types.d.ts.map

package/lib/messagingProtocols/mls/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/messagingProtocols/mls/types.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AAEzD,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAE9B,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACpD,OAAO,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CACvD,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,yBAAyB,EAAE,CAAC,cAAc,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CACzF;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,SAAS,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/messagingProtocols/mls/types.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AAEzD,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAE9B,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACpD,OAAO,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CACvD,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,yBAAyB,EAAE,CAAC,cAAc,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CACzF;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,SAAS,CAAC;AAEd,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;CACtB"}

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/CoreCryptoWrapper/CoreCryptoWrapper.d.ts

@@ -2,19 +2,20 @@ import { PreKey } from '@wireapp/api-client/lib/auth';
 import { CoreCrypto } from '@wireapp/core-crypto';
 import type { CRUDEngine } from '@wireapp/store-engine';
 import { GeneratedKey } from '../../../../../secretStore/secretKeyGenerator';
-import { CoreCryptoConfig } from '../../../../common.types';
 import { CryptoClient } from '../CryptoClient.types';
 type Config = {
-    generateSecretKey: (keyId: string, keySize: 16 | 32) => Promise<GeneratedKey>;
+    generateSecretKey: (keyId: string) => Promise<GeneratedKey>;
     nbPrekeys: number;
     onNewPrekeys: (prekeys: PreKey[]) => void;
+    wasmFilePath: string;
 };
-type ClientConfig = Omit<Config, 'generateSecretKey'> & {
+type ClientConfig = Omit<Config, 'generateSecretKey' | 'wasmFilePath'> & {
     onWipe: () => Promise<void>;
 };
-export declare function buildClient(storeEngine: CRUDEngine, { generateSecretKey, nbPrekeys, onNewPrekeys }: Config, { wasmFilePath }: CoreCryptoConfig): Promise<CoreCryptoWrapper>;
+export declare function buildClient(storeEngine: CRUDEngine, { wasmFilePath, generateSecretKey, nbPrekeys, onNewPrekeys }: Config): Promise<CoreCryptoWrapper>;
 export declare class CoreCryptoWrapper implements CryptoClient {
     private readonly coreCrypto;
+    private readonly config;
     private readonly prekeyTracker;
     readonly version: string;
     constructor(coreCrypto: CoreCrypto, config: ClientConfig);
@@ -42,7 +43,15 @@ export declare class CoreCryptoWrapper implements CryptoClient {
         key: string;
     }>;
     debugBreakSession(sessionId: string): Promise<void>;
+    debugResetIdentity(): Promise<void>;
     migrateFromCryptobox(dbName: string): Promise<void>;
+    /**
+     * Will call the callback once corecrypto is ready.
+     * @param callback - Function to be called once corecrypto is ready.
+     * @see https://github.com/wireapp/wire-web-packages/pull/4972
+     */
+    private onReady;
+    wipe(): Promise<void>;
 }
 export {};
 //# sourceMappingURL=CoreCryptoWrapper.d.ts.map

package/lib/messagingProtocols/proteus/ProteusService/CryptoClient/CoreCryptoWrapper/CoreCryptoWrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CoreCryptoWrapper.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/proteus/ProteusService/CryptoClient/CoreCryptoWrapper/CoreCryptoWrapper.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AAKpD,OAAO,EACL,UAAU,EAQX,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAItD,OAAO,EAAoB,YAAY,EAAC,MAAM,+CAA+C,CAAC;AAC9F,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAC;AAEnD,KAAK,MAAM,GAAG;IACZ,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAC9E,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAC3C,CAAC;AAEF,KAAK,YAAY,GAAG,IAAI,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAAG;IACtD,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B,CAAC;AAiEF,wBAAsB,WAAW,CAC/B,WAAW,EAAE,UAAU,EACvB,EAAC,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAC,EAAE,MAAM,EACpD,EAAC,YAAY,EAAC,EAAE,gBAAgB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAwC5B;AAED,qBAAa,iBAAkB,YAAW,YAAY;IAKlD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAJ7B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,SAAgB,OAAO,EAAE,MAAM,CAAC;gBAGb,UAAU,EAAE,UAAU,EACvC,MAAM,EAAE,YAAY;IAMtB,eAAe;IAIf,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,UAAU;IAIjD,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU;IAI9C,IAAI,CAAC,gBAAgB,CAAC,EAAE,MAAM;IAOxB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU;;;;;;;IAqBpD,cAAc;IAId,oBAAoB,CAAC,SAAS,EAAE,MAAM;IAIhC,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU;IAK/D,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU;IAIvD,aAAa,CAAC,SAAS,EAAE,MAAM;IAI/B,WAAW,CAAC,SAAS,EAAE,MAAM;IAI7B,aAAa,CAAC,SAAS,EAAE,MAAM;IAI/B,aAAa;IAIP,SAAS;;;;IAKT,iBAAiB,CAAC,SAAS,EAAE,MAAM;IAUnC,oBAAoB,CAAC,MAAM,EAAE,MAAM;CAG1C"}
+{"version":3,"file":"CoreCryptoWrapper.d.ts","sourceRoot":"","sources":["../../../../../../src/messagingProtocols/proteus/ProteusService/CryptoClient/CoreCryptoWrapper/CoreCryptoWrapper.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AAKpD,OAAO,EAAC,UAAU,EAAgD,MAAM,sBAAsB,CAAC;AAC/F,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAItD,OAAO,EAAoB,YAAY,EAAC,MAAM,+CAA+C,CAAC;AAC9F,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAC;AAEnD,KAAK,MAAM,GAAG;IACZ,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAC1C,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,KAAK,YAAY,GAAG,IAAI,CAAC,MAAM,EAAE,mBAAmB,GAAG,cAAc,CAAC,GAAG;IACvE,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B,CAAC;AAmBF,wBAAsB,WAAW,CAC/B,WAAW,EAAE,UAAU,EACvB,EAAC,YAAY,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAC,EAAE,MAAM,GACjE,OAAO,CAAC,iBAAiB,CAAC,CAyB5B;AAED,qBAAa,iBAAkB,YAAW,YAAY;IAKlD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IALzB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,SAAgB,OAAO,EAAE,MAAM,CAAC;gBAGb,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,YAAY;IAMvC,eAAe;IAIf,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,UAAU;IAIjD,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU;IAI9C,IAAI,CAAC,gBAAgB,CAAC,EAAE,MAAM;IAOxB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU;;;;;;;IAqBpD,cAAc;IAId,oBAAoB,CAAC,SAAS,EAAE,MAAM;IAIhC,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU;IAK/D,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU;IAIvD,aAAa,CAAC,SAAS,EAAE,MAAM;IAI/B,WAAW,CAAC,SAAS,EAAE,MAAM;IAI7B,aAAa,CAAC,SAAS,EAAE,MAAM;IAI/B,aAAa;IAIP,SAAS;;;;IAKT,iBAAiB,CAAC,SAAS,EAAE,MAAM;IAUnC,kBAAkB;IAIlB,oBAAoB,CAAC,MAAM,EAAE,MAAM;IAIzC;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAgBT,IAAI;CAIX"}