@wireapp/core 40.5.1 → 40.5.2-1

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.mocks.d.ts

@@ -1,7 +1,7 @@
 import { APIClient } from '@wireapp/api-client';
 import { CryptoClient } from './CryptoClient';
 import { ProteusService } from './ProteusService';
-export declare const buildProteusService: () => Promise<[ProteusService, {
+export declare const buildProteusService: (federated?: boolean) => Promise<[ProteusService, {
     apiClient: APIClient;
     cryptoClient: CryptoClient;
 }]>;

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.mocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProteusService.mocks.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.mocks.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAE9C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAIhD,eAAO,MAAM,mBAAmB;eACD,SAAS;kBAAgB,YAAY;GAgBnE,CAAC"}
+{"version":3,"file":"ProteusService.mocks.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.mocks.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAE9C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAIhD,eAAO,MAAM,mBAAmB;eAEQ,SAAS;kBAAgB,YAAY;GAgB5E,CAAC"}

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.mocks.js

@@ -24,16 +24,17 @@ const api_client_1 = require("@wireapp/api-client");
 const CoreCryptoWrapper_1 = require("./CryptoClient/CoreCryptoWrapper/CoreCryptoWrapper");
 const ProteusService_1 = require("./ProteusService");
 const PayloadHelper_1 = require("../../../test/PayloadHelper");
-const buildProteusService = async () => {
+const buildProteusService = async (federated = false) => {
     const apiClient = new api_client_1.APIClient({ urls: api_client_1.APIClient.BACKEND.STAGING });
     apiClient.context = {
         clientType: client_1.ClientType.NONE,
         userId: (0, PayloadHelper_1.getUUID)(),
         clientId: (0, PayloadHelper_1.getUUID)(),
     };
-    const cryptoClient = new CoreCryptoWrapper_1.CoreCryptoWrapper({}, {});
+    const cryptoClient = new CoreCryptoWrapper_1.CoreCryptoWrapper({}, {}, {});
     const proteusService = new ProteusService_1.ProteusService(apiClient, cryptoClient, {
         nbPrekeys: 0,
+        useQualifiedIds: federated,
     });
     return [proteusService, { apiClient, cryptoClient }];
 };

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.test.js

@@ -64,11 +64,11 @@ jest.mock('./CryptoClient/CoreCryptoWrapper/PrekeysTracker', () => {
 });
 jest.mock('../Utility/Recipients', () => (Object.assign(Object.assign({}, jest.requireActual('../Utility/Recipients')), { getRecipientsForConversation: jest.fn(), getQualifiedRecipientsForConversation: jest.fn() })));
 const MockedRecipients = Recipients;
-const prepareDataForEncryption = async () => {
-    const [proteusService, { cryptoClient, apiClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
+const prepareDataForEncryption = async (useQualifiedIds = true) => {
+    const [proteusService, { cryptoClient, apiClient }] = await (0, ProteusService_mocks_1.buildProteusService)(useQualifiedIds);
     const domain = 'staging.zinfra.io';
     //user 1
-    const firstUserId = { id: 'bc0c99f1-49a5-4ad2-889a-62885af37088', domain };
+    const firstUserId = 'bc0c99f1-49a5-4ad2-889a-62885af37088';
     //user 1 clients
     const firstClientId = 'be67218b77d02d30';
     const secondClientId = 'ae87218e77d02d30';
@@ -76,19 +76,25 @@ const prepareDataForEncryption = async () => {
     const firstClientSessionId = (0, SessionHandler_1.constructSessionId)({
         userId: firstUserId,
         clientId: firstClientId,
+        useQualifiedIds,
+        domain: useQualifiedIds ? domain : undefined,
     });
     const firstClientSession2Id = (0, SessionHandler_1.constructSessionId)({
         userId: firstUserId,
         clientId: secondClientId,
+        useQualifiedIds,
+        domain: useQualifiedIds ? domain : undefined,
     });
     //user 2
-    const secondUserId = { id: 'cd0c88f1-49a5-4ar2-889a-62885af37069', domain };
+    const secondUserId = 'cd0c88f1-49a5-4ar2-889a-62885af37069';
     //user 2 client
     const thirdClientId = 'ce67218b77d02d69';
     //user 2 sessions
     const secondClientSessionId = (0, SessionHandler_1.constructSessionId)({
         userId: secondUserId,
         clientId: thirdClientId,
+        useQualifiedIds,
+        domain: useQualifiedIds ? domain : undefined,
     });
     //message sent by a user
     const message = 'Hello';
@@ -128,14 +134,12 @@ describe('ProteusService', () => {
             const expectedFingerprint = 'fingerprint-client1';
             const userId = { id: 'user1', domain: 'domain.com' };
             const clientId = 'client1';
-            jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue({
-                qualified_user_client_prekeys: {
-                    [userId.domain]: {
-                        [userId.id]: {
-                            [clientId]: {
-                                id: 123,
-                                key: 'pQABARhIAqEAWCCaJpFa9c626ORmjj1aV6OnOYgmTjfoiE3ynOfNfGAOmgOhAKEAWCD60VMzRrLfO+1GSjgyhnVp2N7L58DM+eeJhZJi1tBLfQT2',
-                            },
+            jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockResolvedValue({
+                [userId.domain]: {
+                    [userId.id]: {
+                        [clientId]: {
+                            id: 123,
+                            key: 'pQABARhIAqEAWCCaJpFa9c626ORmjj1aV6OnOYgmTjfoiE3ynOfNfGAOmgOhAKEAWCD60VMzRrLfO+1GSjgyhnVp2N7L58DM+eeJhZJi1tBLfQT2',
                         },
                     },
                 },
@@ -150,9 +154,9 @@ describe('ProteusService', () => {
         it('create a session from given prekey if session does not exists', async () => {
             const [proteusService, { apiClient, cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
             const expectedFingerprint = 'fingerprint-client1';
-            const getPrekeysSpy = jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles');
+            const getPrekeyMock = jest.spyOn(apiClient.api.user, 'getClientPreKey');
             jest.spyOn(cryptoClient, 'getRemoteFingerprint').mockResolvedValue(expectedFingerprint);
-            const saveSessionSpy = jest.spyOn(cryptoClient, 'sessionFromPrekey').mockResolvedValue(undefined);
+            jest.spyOn(cryptoClient, 'sessionFromPrekey').mockResolvedValue(undefined);
             jest.spyOn(cryptoClient, 'saveSession').mockResolvedValue(undefined);
             jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
             const userId = { id: 'user1', domain: 'domain.com' };
@@ -161,8 +165,7 @@ describe('ProteusService', () => {
                 key: 'pQABARhIAqEAWCCaJpFa9c626ORmjj1aV6OnOYgmTjfoiE3ynOfNfGAOmgOhAKEAWCD60VMzRrLfO+1GSjgyhnVp2N7L58DM+eeJhZJi1tBLfQT2',
                 id: 123,
             });
-            expect(saveSessionSpy).toHaveBeenCalled();
-            expect(getPrekeysSpy).not.toHaveBeenCalled();
+            expect(getPrekeyMock).not.toHaveBeenCalled();
             expect(result).toBe(expectedFingerprint);
         });
         it('returns the fingerprint from existing session', async () => {
@@ -217,64 +220,83 @@ describe('ProteusService', () => {
     });
     describe('"encrypt"', () => {
         it('returns encrypted payload', async () => {
-            const { services, data: { firstUser, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
+            const { services, data: { firstUser, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
             const userClients = {
-                [domain]: {
-                    [firstUser.id.id]: [firstUser.clients.first, firstUser.clients.second],
+                [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
+            };
+            const encryptedPayload = new Map([
+                [firstUser.sessions.first, encryptedMessageBuffer],
+                [firstUser.sessions.second, encryptedMessageBuffer],
+            ]);
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
+            jest.spyOn(services.cryptoClient, 'encrypt').mockImplementationOnce(() => Promise.resolve(encryptedPayload));
+            const encrypted = await services.proteusService.encrypt(messageBuffer, userClients);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
+            expect(encrypted).toEqual({
+                [firstUser.id]: {
+                    [firstUser.clients.first]: encryptedMessageBuffer,
+                    [firstUser.clients.second]: encryptedMessageBuffer,
                 },
+            });
+        });
+        it('returns encrypted payload for multiple users', async () => {
+            const { services, data: { firstUser, secondUser, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
+            const userClients = {
+                [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
+                [secondUser.id]: [secondUser.clients.first],
             };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
                 [firstUser.sessions.second, encryptedMessageBuffer],
+                [secondUser.sessions.first, encryptedMessageBuffer],
             ]);
             jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
             jest.spyOn(services.cryptoClient, 'encrypt').mockResolvedValueOnce(encryptedPayload);
-            const { payloads } = await services.proteusService.encrypt(messageBuffer, userClients);
-            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
-            expect(payloads).toEqual({
-                [domain]: {
-                    [firstUser.id.id]: {
-                        [firstUser.clients.first]: encryptedMessageBuffer,
-                        [firstUser.clients.second]: encryptedMessageBuffer,
-                    },
+            const encrypted = await services.proteusService.encrypt(messageBuffer, userClients);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second, secondUser.sessions.first], messageBuffer);
+            expect(encrypted).toEqual({
+                [firstUser.id]: {
+                    [firstUser.clients.first]: encryptedMessageBuffer,
+                    [firstUser.clients.second]: encryptedMessageBuffer,
+                },
+                [secondUser.id]: {
+                    [secondUser.clients.first]: encryptedMessageBuffer,
                 },
             });
         });
-        it('returns missing clients and encrypted payload for multiple users', async () => {
-            const { services, data: { firstUser, secondUser, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
+    });
+    describe('"encryptQualified"', () => {
+        it('returns encrypted payload', async () => {
+            const { services, data: { firstUser, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
             const userClients = {
                 [domain]: {
-                    [firstUser.id.id]: [firstUser.clients.first, firstUser.clients.second],
-                    [secondUser.id.id]: [secondUser.clients.first],
+                    [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
                 },
             };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
                 [firstUser.sessions.second, encryptedMessageBuffer],
-                [secondUser.sessions.first, encryptedMessageBuffer],
             ]);
             jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
             jest.spyOn(services.cryptoClient, 'encrypt').mockResolvedValueOnce(encryptedPayload);
-            const { payloads } = await services.proteusService.encrypt(messageBuffer, userClients);
-            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second, secondUser.sessions.first], messageBuffer);
-            expect(payloads).toEqual({
+            const encrypted = await services.proteusService.encryptQualified(messageBuffer, userClients);
+            // console.log({encrypted, missing});
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
+            expect(encrypted).toEqual({
                 [domain]: {
-                    [firstUser.id.id]: {
+                    [firstUser.id]: {
                         [firstUser.clients.first]: encryptedMessageBuffer,
                         [firstUser.clients.second]: encryptedMessageBuffer,
                     },
-                    [secondUser.id.id]: {
-                        [secondUser.clients.first]: encryptedMessageBuffer,
-                    },
                 },
             });
         });
-        it('returns the unknown clients that are deleted on backend', async () => {
+        it('returns missing clients and encrypted payload for multiple users', async () => {
             const { services, data: { firstUser, secondUser, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
             const userClients = {
                 [domain]: {
-                    [firstUser.id.id]: [firstUser.clients.first, firstUser.clients.second],
-                    [secondUser.id.id]: [secondUser.clients.first],
+                    [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
+                    [secondUser.id]: [secondUser.clients.first],
                 },
             };
             const encryptedPayload = new Map([
@@ -282,43 +304,17 @@ describe('ProteusService', () => {
                 [firstUser.sessions.second, encryptedMessageBuffer],
                 [secondUser.sessions.first, encryptedMessageBuffer],
             ]);
-            jest.spyOn(services.apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue({
-                qualified_user_client_prekeys: {
-                    [domain]: {
-                        [firstUser.id.id]: {
-                            [firstUser.clients.first]: null,
-                            [firstUser.clients.second]: {
-                                id: 123,
-                                key: 'pQABARhIAqEAWCCaJpFa9c626ORmjj1aV6OnOYgmTjfoiE3ynOfNfGAOmgOhAKEAWCD60VMzRrLfO+1GSjgyhnVp2N7L58DM+eeJhZJi1tBLfQT2',
-                            },
-                        },
-                        [secondUser.id.id]: {
-                            [secondUser.clients.first]: {
-                                id: 123,
-                                key: 'pQABARhIAqEAWCCaJpFa9c626ORmjj1aV6OnOYgmTjfoiE3ynOfNfGAOmgOhAKEAWCD60VMzRrLfO+1GSjgyhnVp2N7L58DM+eeJhZJi1tBLfQT2',
-                            },
-                        },
-                    },
-                },
-            });
-            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(false);
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
             jest.spyOn(services.cryptoClient, 'encrypt').mockResolvedValueOnce(encryptedPayload);
-            jest.spyOn(services.cryptoClient, 'sessionFromPrekey').mockResolvedValue();
-            jest.spyOn(services.cryptoClient, 'saveSession').mockResolvedValue();
-            const { payloads, unknowns } = await services.proteusService.encrypt(messageBuffer, userClients);
-            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.second, secondUser.sessions.first], messageBuffer);
-            expect(unknowns).toEqual({
-                [domain]: {
-                    [firstUser.id.id]: [firstUser.clients.first],
-                },
-            });
-            expect(payloads).toEqual({
+            const encrypted = await services.proteusService.encryptQualified(messageBuffer, userClients);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second, secondUser.sessions.first], messageBuffer);
+            expect(encrypted).toEqual({
                 [domain]: {
-                    [firstUser.id.id]: {
+                    [firstUser.id]: {
                         [firstUser.clients.first]: encryptedMessageBuffer,
                         [firstUser.clients.second]: encryptedMessageBuffer,
                     },
-                    [secondUser.id.id]: {
+                    [secondUser.id]: {
                         [secondUser.clients.first]: encryptedMessageBuffer,
                     },
                 },
@@ -348,13 +344,7 @@ describe('ProteusService', () => {
                     expect(errorMessage).toContain('no userIds are given');
                 }
             });
-            [
-                { domain: { user1: ['client1'], user2: ['client11', 'client12'] } },
-                [
-                    { domain: 'domain', id: 'user1' },
-                    { domain: 'domain', id: 'user2' },
-                ],
-            ].forEach(recipients => {
+            [{ user1: ['client1'], user2: ['client11', 'client12'] }, ['user1', 'user2']].forEach(recipients => {
                 it(`forwards the list of users to report (${JSON.stringify(recipients)})`, async () => {
                     const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)();
                     MockedRecipients.getRecipientsForConversation.mockResolvedValue({});
@@ -366,12 +356,7 @@ describe('ProteusService', () => {
                         userIds: recipients,
                         conversationId: { id: 'conv1', domain: '' },
                     });
-                    expect(proteusService['messageService'].sendMessage).toHaveBeenCalledWith(expect.any(String), expect.any(Object), expect.any(Uint8Array), expect.objectContaining({
-                        reportMissing: [
-                            { domain: 'domain', id: 'user1' },
-                            { domain: 'domain', id: 'user2' },
-                        ],
-                    }));
+                    expect(proteusService['messageService'].sendMessage).toHaveBeenCalledWith(expect.any(String), expect.any(Object), expect.any(Uint8Array), expect.objectContaining({ reportMissing: ['user1', 'user2'] }));
                 });
             });
             [
@@ -383,9 +368,9 @@ describe('ProteusService', () => {
                 ],
             ].forEach(recipients => {
                 it(`forwards the list of users to report for federated message (${JSON.stringify(recipients)})`, async () => {
-                    const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)();
-                    MockedRecipients.getRecipientsForConversation.mockResolvedValue({});
-                    jest.spyOn(proteusService['messageService'], 'sendMessage').mockResolvedValue({});
+                    const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)(true);
+                    MockedRecipients.getQualifiedRecipientsForConversation.mockResolvedValue({});
+                    jest.spyOn(proteusService['messageService'], 'sendFederatedMessage').mockResolvedValue({});
                     await proteusService.sendMessage({
                         protocol: conversation_1.ConversationProtocol.PROTEUS,
                         conversationId: { id: 'conv1', domain: 'domain1' },
@@ -393,7 +378,7 @@ describe('ProteusService', () => {
                         targetMode: conversation_2.MessageTargetMode.USERS,
                         userIds: recipients,
                     });
-                    expect(proteusService['messageService'].sendMessage).toHaveBeenCalledWith(expect.any(String), expect.any(Object), expect.any(Uint8Array), expect.objectContaining({
+                    expect(proteusService['messageService'].sendFederatedMessage).toHaveBeenCalledWith(expect.any(String), expect.any(Object), expect.any(Uint8Array), expect.objectContaining({
                         reportMissing: [
                             { id: 'user1', domain: 'domain1' },
                             { id: 'user2', domain: 'domain1' },
@@ -402,15 +387,9 @@ describe('ProteusService', () => {
                     }));
                 });
             });
-            [
-                { domain: { user1: ['client1'], user2: ['client11', 'client12'] } },
-                [
-                    { domain: 'domain', id: 'user1' },
-                    { domain: 'domain', id: 'user2' },
-                ],
-            ].forEach(recipients => {
+            [{ user1: ['client1'], user2: ['client11', 'client12'] }, ['user1', 'user2']].forEach(recipients => {
                 it(`ignores all missing user/client pair if targetMode is USER_CLIENTS`, async () => {
-                    const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)();
+                    const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)(false);
                     MockedRecipients.getRecipientsForConversation.mockReturnValue(Promise.resolve({}));
                     jest.spyOn(proteusService['messageService'], 'sendMessage').mockReturnValue(Promise.resolve({}));
                     await proteusService.sendMessage({
@@ -432,9 +411,11 @@ describe('ProteusService', () => {
                 ],
             ].forEach(recipients => {
                 it(`ignores all missing user/client pair if targetMode is USER_CLIENTS on federated env`, async () => {
-                    const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)();
-                    MockedRecipients.getRecipientsForConversation.mockResolvedValue({});
-                    jest.spyOn(proteusService['messageService'], 'sendMessage').mockReturnValue(Promise.resolve({}));
+                    const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)(true);
+                    MockedRecipients.getQualifiedRecipientsForConversation.mockResolvedValue({});
+                    jest
+                        .spyOn(proteusService['messageService'], 'sendFederatedMessage')
+                        .mockReturnValue(Promise.resolve({}));
                     await proteusService.sendMessage({
                         protocol: conversation_1.ConversationProtocol.PROTEUS,
                         conversationId: { id: 'conv1', domain: 'domain1' },
@@ -442,20 +423,19 @@ describe('ProteusService', () => {
                         targetMode: conversation_2.MessageTargetMode.USERS_CLIENTS,
                         userIds: recipients,
                     });
-                    expect(proteusService['messageService'].sendMessage).toHaveBeenCalledWith(expect.any(String), expect.any(Object), expect.any(Uint8Array), expect.objectContaining({
+                    expect(proteusService['messageService'].sendFederatedMessage).toHaveBeenCalledWith(expect.any(String), expect.any(Object), expect.any(Uint8Array), expect.objectContaining({
                         reportMissing: false,
                     }));
                 });
             });
-            it(`returns the recipients that will receive the message later`, async () => {
-                var _a;
-                const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)();
+            it(`returns the recipients that could not receive the message`, async () => {
+                const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)(true);
                 const recipients = {
                     domain1: { user1: ['client1'], user2: ['client11', 'client12'] },
                     domain2: { user3: ['client3'] },
                 };
-                MockedRecipients.getRecipientsForConversation.mockResolvedValue({});
-                jest.spyOn(proteusService['messageService'], 'sendMessage').mockResolvedValue({
+                MockedRecipients.getQualifiedRecipientsForConversation.mockResolvedValue({});
+                jest.spyOn(proteusService['messageService'], 'sendFederatedMessage').mockResolvedValue({
                     missing: {},
                     redundant: {},
                     failed_to_send: { domain2: recipients.domain2 },
@@ -470,7 +450,7 @@ describe('ProteusService', () => {
                     userIds: recipients,
                 });
                 expect(result.state).toBe(conversation_2.MessageSendingState.OUTGOING_SENT);
-                expect((_a = result.failedToSend) === null || _a === void 0 ? void 0 : _a.queued).toEqual({ domain2: recipients.domain2 });
+                expect(result.failedToSend).toEqual({ domain2: recipients.domain2 });
             });
         });
     });

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.types.d.ts

@@ -1,4 +1,4 @@
-import { QualifiedUserClients, MessageSendingStatus, ConversationProtocol, NewConversation } from '@wireapp/api-client/lib/conversation';
+import { UserClients, QualifiedUserClients, ClientMismatch, MessageSendingStatus, ConversationProtocol, NewConversation } from '@wireapp/api-client/lib/conversation';
 import { QualifiedId } from '@wireapp/api-client/lib/user';
 import { AddUsersParams, MessageSendingOptions, SendCommonParams } from '../../../conversation';
 export interface NewClient {
@@ -6,18 +6,21 @@ export interface NewClient {
     userId: QualifiedId;
 }
 export type ProteusServiceConfig = {
+    useQualifiedIds: boolean;
     onNewClient?: (client: NewClient) => void;
     nbPrekeys: number;
 };
 export type SendProteusMessageParams = SendCommonParams & MessageSendingOptions & {
     conversationId: QualifiedId;
     /**
-     * Can be either a QualifiedId[] or QualfiedUserClients. The type has some effect on the behavior of the method. (Needed only for Proteus)
-     *    When given a QualifiedId[] the method will fetch the freshest list of devices for those users (since they are not given by the consumer). As a consequence no ClientMismatch error will trigger and we will ignore missing clients when sending
-     *    When given a QualifiedUserClients the method will only send to the clients listed in the userIds. This could lead to ClientMismatch (since the given list of devices might not be the freshest one and new clients could have been created)
+     * Can be either a QualifiedId[], string[], UserClients or QualfiedUserClients. The type has some effect on the behavior of the method. (Needed only for Proteus)
+     *    When given a QualifiedId[] or string[] the method will fetch the freshest list of devices for those users (since they are not given by the consumer). As a consequence no ClientMismatch error will trigger and we will ignore missing clients when sending
+     *    When given a QualifiedUserClients or UserClients the method will only send to the clients listed in the userIds. This could lead to ClientMismatch (since the given list of devices might not be the freshest one and new clients could have been created)
+     *    When given a QualifiedId[] or QualifiedUserClients the method will send the message through the federated API endpoint
+     *    When given a string[] or UserClients the method will send the message through the old API endpoint
      */
-    userIds?: QualifiedId[] | QualifiedUserClients;
-    onClientMismatch?: (status: MessageSendingStatus, wasSent: boolean) => void | boolean | Promise<boolean>;
+    userIds?: string[] | QualifiedId[] | UserClients | QualifiedUserClients;
+    onClientMismatch?: (status: ClientMismatch | MessageSendingStatus, wasSent: boolean) => void | boolean | Promise<boolean>;
     protocol: ConversationProtocol.PROTEUS;
 };
 export type CreateProteusConversationParams = {

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProteusService.types.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.types.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EAChB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AAEzD,OAAO,EAAC,cAAc,EAAE,qBAAqB,EAAE,gBAAgB,EAAC,MAAM,uBAAuB,CAAC;AAE9F,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC;CACrB;AACD,MAAM,MAAM,oBAAoB,GAAG;IACjC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,gBAAgB,GACrD,qBAAqB,GAAG;IACtB,cAAc,EAAE,WAAW,CAAC;IAE5B;;;;OAIG;IACH,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,oBAAoB,CAAC;IAC/C,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACzG,QAAQ,EAAE,oBAAoB,CAAC,OAAO,CAAC;CACxC,CAAC;AAEJ,MAAM,MAAM,+BAA+B,GAAG;IAC5C,gBAAgB,EAAE,eAAe,GAAG,MAAM,CAAC;IAC3C,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC"}
+{"version":3,"file":"ProteusService.types.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.types.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,WAAW,EACX,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EAChB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AAEzD,OAAO,EAAC,cAAc,EAAE,qBAAqB,EAAE,gBAAgB,EAAC,MAAM,uBAAuB,CAAC;AAE9F,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC;CACrB;AACD,MAAM,MAAM,oBAAoB,GAAG;IACjC,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,gBAAgB,GACrD,qBAAqB,GAAG;IACtB,cAAc,EAAE,WAAW,CAAC;IAE5B;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,GAAG,WAAW,GAAG,oBAAoB,CAAC;IACxE,gBAAgB,CAAC,EAAE,CACjB,MAAM,EAAE,cAAc,GAAG,oBAAoB,EAC7C,OAAO,EAAE,OAAO,KACb,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,QAAQ,EAAE,oBAAoB,CAAC,OAAO,CAAC;CACxC,CAAC;AAEJ,MAAM,MAAM,+BAA+B,GAAG;IAC5C,gBAAgB,EAAE,eAAe,GAAG,MAAM,CAAC;IAC3C,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC"}

package/lib/messagingProtocols/proteus/Utility/PreKeyBundle/PreKeyBundle.d.ts

@@ -0,0 +1,25 @@
+import { APIClient } from '@wireapp/api-client/lib/APIClient';
+import { QualifiedUserClients, UserClients } from '@wireapp/api-client/lib/conversation';
+import { QualifiedId, QualifiedUserPreKeyBundleMap, UserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
+declare const preKeyBundleToUserClients: (users: UserPreKeyBundleMap) => UserClients;
+interface GetPreKeyBundleMapParams {
+    apiClient: APIClient;
+    conversationId: QualifiedId;
+    userIds?: string[] | QualifiedId[] | UserClients;
+}
+declare const getPreKeyBundleMap: ({ apiClient, conversationId, userIds, }: GetPreKeyBundleMapParams) => Promise<UserPreKeyBundleMap>;
+/**
+ * Will generate a prekey bundle for specific users.
+ * If a QualifiedId array is given the bundle will contain all the clients from those users fetched from the server.
+ * If a QualifiedUserClients is provided then only the clients in the payload will be targeted (which could generate a ClientMismatch when sending messages)
+ *
+ * @param {QualifiedId[]|QualifiedUserClients} userIds - Targeted users.
+ * @returns {Promise<QualifiedUserPreKeyBundleMap}
+ */
+interface GetQualifiedPreKeyBundleMapParams {
+    apiClient: APIClient;
+    userIds?: QualifiedId[] | QualifiedUserClients;
+}
+declare const getQualifiedPreKeyBundle: ({ apiClient, userIds, }: GetQualifiedPreKeyBundleMapParams) => Promise<QualifiedUserPreKeyBundleMap>;
+export { getPreKeyBundleMap, getQualifiedPreKeyBundle, preKeyBundleToUserClients };
+//# sourceMappingURL=PreKeyBundle.d.ts.map

package/lib/messagingProtocols/proteus/Utility/PreKeyBundle/PreKeyBundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreKeyBundle.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/proteus/Utility/PreKeyBundle/PreKeyBundle.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AAC5D,OAAO,EAAC,oBAAoB,EAAE,WAAW,EAAC,MAAM,sCAAsC,CAAC;AACvF,OAAO,EAAC,WAAW,EAAE,4BAA4B,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAI5G,QAAA,MAAM,yBAAyB,UAAW,mBAAmB,KAAG,WAK/D,CAAC;AAEF,UAAU,wBAAwB;IAChC,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,WAAW,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,GAAG,WAAW,CAAC;CAClD;AACD,QAAA,MAAM,kBAAkB,4CAIrB,wBAAwB,KAAG,QAAQ,mBAAmB,CA+BxD,CAAC;AAEF;;;;;;;GAOG;AACH,UAAU,iCAAiC;IACzC,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,oBAAoB,CAAC;CAChD;AACD,QAAA,MAAM,wBAAwB,4BAG3B,iCAAiC,KAAG,QAAQ,4BAA4B,CAoC1E,CAAC;AAEF,OAAO,EAAC,kBAAkB,EAAE,wBAAwB,EAAE,yBAAyB,EAAC,CAAC"}

package/lib/messagingProtocols/proteus/Utility/PreKeyBundle/PreKeyBundle.js

@@ -0,0 +1,93 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2022 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preKeyBundleToUserClients = exports.getQualifiedPreKeyBundle = exports.getPreKeyBundleMap = void 0;
+const util_1 = require("../../../../util");
+const preKeyBundleToUserClients = (users) => {
+    return Object.entries(users).reduce((acc, [userId, clientsObj]) => {
+        acc[userId] = Object.keys(clientsObj);
+        return acc;
+    }, {});
+};
+exports.preKeyBundleToUserClients = preKeyBundleToUserClients;
+const getPreKeyBundleMap = async ({ apiClient, conversationId, userIds = [], }) => {
+    let members = [];
+    if (userIds) {
+        if ((0, util_1.isStringArray)(userIds)) {
+            members = userIds;
+        }
+        else if ((0, util_1.isUserClients)(userIds)) {
+            members = Object.keys(userIds);
+        }
+    }
+    if (!members.length) {
+        const conversation = await apiClient.api.conversation.getConversation(conversationId);
+        /*
+         * If you are sending a message to a conversation, you have to include
+         * yourself in the list of users if you want to sync a message also to your
+         * other clients.
+         */
+        members = conversation.members.others.map(member => member.id).concat(conversation.members.self.id);
+    }
+    const preKeys = await Promise.all(members.map(member => apiClient.api.user.getUserPreKeys(member)));
+    return preKeys.reduce((bundleMap, bundle) => {
+        const userId = bundle.user;
+        bundleMap[userId] || (bundleMap[userId] = {});
+        for (const client of bundle.clients) {
+            bundleMap[userId][client.client] = client.prekey;
+        }
+        return bundleMap;
+    }, {});
+};
+exports.getPreKeyBundleMap = getPreKeyBundleMap;
+const getQualifiedPreKeyBundle = async ({ apiClient, userIds, }) => {
+    let targets = [];
+    if (userIds) {
+        if ((0, util_1.isQualifiedIdArray)(userIds)) {
+            targets = userIds.map(id => ({ id }));
+        }
+        else {
+            targets = Object.entries(userIds).reduce((accumulator, [domain, userClients]) => {
+                for (const userId in userClients) {
+                    accumulator.push({ id: { id: userId, domain }, clients: userClients[userId] });
+                }
+                return accumulator;
+            }, []);
+        }
+    }
+    const preKeys = await Promise.all(targets.map(async ({ id: userId, clients }) => {
+        const prekeyBundle = await apiClient.api.user.getUserPreKeys(userId);
+        // We filter the clients that should not receive the message (if a QualifiedUserClients was given as parameter)
+        const userClients = clients
+            ? prekeyBundle.clients.filter(client => clients.includes(client.client))
+            : prekeyBundle.clients;
+        return { user: userId, clients: userClients };
+    }));
+    return preKeys.reduce((bundleMap, qualifiedPrekey) => {
+        var _a, _b, _c;
+        bundleMap[_a = qualifiedPrekey.user.domain] || (bundleMap[_a] = {});
+        for (const client of qualifiedPrekey.clients) {
+            (_b = bundleMap[qualifiedPrekey.user.domain])[_c = qualifiedPrekey.user.id] || (_b[_c] = {});
+            bundleMap[qualifiedPrekey.user.domain][qualifiedPrekey.user.id][client.client] = client.prekey;
+        }
+        return bundleMap;
+    }, {});
+};
+exports.getQualifiedPreKeyBundle = getQualifiedPreKeyBundle;

package/lib/messagingProtocols/proteus/Utility/PreKeyBundle/PreKeyBundle.test.d.ts

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

package/lib/messagingProtocols/proteus/Utility/PreKeyBundle/PreKeyBundle.test.d.ts.map

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

package/lib/messagingProtocols/proteus/Utility/PreKeyBundle/PreKeyBundle.test.js

@@ -0,0 +1,66 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2022 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const PreKeyBundle_1 = require("./PreKeyBundle");
+const firstUser = {
+    id: 'bc0c99f1-49a5-4ad2-889a-62885af37088',
+    clients: { first: 'be67218b77d02d30', second: 'ae87218e77d02d30' },
+};
+const secondUser = {
+    id: 'bc0c99ff-ffa5-ffd2-ff9a-6ff85af3ff88',
+    clients: { first: 'kk67218b77d02d30', second: 'kk87218e77d02d30' },
+};
+const validPreKey = {
+    id: 1337,
+    key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
+};
+describe('PrekeyHandler', () => {
+    describe('preKeyBundleToUserClients', () => {
+        it('maps preKeyBundle to userClients', () => {
+            const input = {
+                [firstUser.id]: { [firstUser.clients.first]: validPreKey },
+            };
+            const output = {
+                [firstUser.id]: [firstUser.clients.first],
+            };
+            expect((0, PreKeyBundle_1.preKeyBundleToUserClients)(input)).toEqual(output);
+        });
+        it('maps preKeyBundle to userClients (multiple clients)', () => {
+            const input = {
+                [firstUser.id]: { [firstUser.clients.first]: validPreKey, [firstUser.clients.second]: validPreKey },
+            };
+            const output = {
+                [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
+            };
+            expect((0, PreKeyBundle_1.preKeyBundleToUserClients)(input)).toEqual(output);
+        });
+        it('maps preKeyBundle to userClients (multiple users)', () => {
+            const input = {
+                [firstUser.id]: { [firstUser.clients.first]: validPreKey, [firstUser.clients.second]: validPreKey },
+                [secondUser.id]: { [secondUser.clients.first]: validPreKey, [secondUser.clients.second]: validPreKey },
+            };
+            const output = {
+                [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
+                [secondUser.id]: [secondUser.clients.first, secondUser.clients.second],
+            };
+            expect((0, PreKeyBundle_1.preKeyBundleToUserClients)(input)).toEqual(output);
+        });
+    });
+});