@wireapp/core 38.15.2 → 39.0.0

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

@@ -1,22 +1,21 @@
 import { PreKey } from '@wireapp/api-client/lib/auth';
-import { UserClients } from '@wireapp/api-client/lib/conversation';
-import { QualifiedId, UserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
+import { QualifiedUserClients } from '@wireapp/api-client/lib/conversation';
+import { QualifiedId, QualifiedUserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
 import { Logger } from 'logdown';
 import { APIClient } from '@wireapp/api-client';
 import { CryptoClient } from '../../ProteusService/CryptoClient';
 interface ConstructSessionIdParams {
-    userId: string | QualifiedId;
+    userId: QualifiedId;
     clientId: string;
-    useQualifiedIds: boolean;
     domain?: string;
 }
 type InitSessionsResult = {
     /** valid sessions that either already existed or have been freshly created */
     sessions: string[];
     /** client that do we do not have sessions with and that do not have existence on backend (deleted clients) */
-    unknowns?: UserClients;
+    unknowns?: QualifiedUserClients;
 };
-declare const constructSessionId: ({ userId, clientId, useQualifiedIds, domain }: ConstructSessionIdParams) => string;
+declare const constructSessionId: ({ userId, clientId }: ConstructSessionIdParams) => string;
 /**
  * Will make sure the session is available in cryptoClient
  * @param sessionId the session to init
@@ -30,8 +29,7 @@ declare const initSession: ({ userId, clientId, initialPrekey }: {
     cryptoClient: CryptoClient;
 }) => Promise<string>;
 interface GetSessionsAndClientsFromRecipientsProps {
-    recipients: UserClients | UserPreKeyBundleMap;
-    domain?: string;
+    recipients: QualifiedUserClients | QualifiedUserPreKeyBundleMap;
     apiClient: APIClient;
     cryptoClient: CryptoClient;
     logger?: Logger;
@@ -39,15 +37,14 @@ interface GetSessionsAndClientsFromRecipientsProps {
 /**
  * Will make sure all the sessions need to encrypt for those user/clients pair are set
  */
-declare const initSessions: ({ recipients, domain, apiClient, cryptoClient, logger, }: GetSessionsAndClientsFromRecipientsProps) => Promise<InitSessionsResult>;
+declare const initSessions: ({ recipients, apiClient, cryptoClient, logger, }: GetSessionsAndClientsFromRecipientsProps) => Promise<InitSessionsResult>;
 interface DeleteSessionParams {
     userId: QualifiedId;
     clientId: string;
     cryptoClient: CryptoClient;
-    useQualifiedIds: boolean;
 }
 declare function deleteSession(params: DeleteSessionParams): Promise<void>;
-type EncryptedPayloads<T> = Record<string, Record<string, T>>;
+type EncryptedPayloads<T> = Record<string, Record<string, Record<string, T>>>;
 /**
  * creates an encrypted payload that can be sent to backend from a bunch of sessionIds/encrypted payload
  */

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

@@ -1 +1 @@
-{"version":3,"file":"SessionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAC,WAAW,EAAC,MAAM,sCAAsC,CAAC;AACjE,OAAO,EAAC,WAAW,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAE9E,OAAO,EAAC,MAAM,EAAC,MAAM,SAAS,CAAC;AAE/B,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAK9C,OAAO,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAE/D,UAAU,wBAAwB;IAChC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,KAAK,kBAAkB,GAAG;IACxB,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8GAA8G;IAC9G,QAAQ,CAAC,EAAE,WAAW,CAAC;CACxB,CAAC;AAEF,QAAA,MAAM,kBAAkB,kDAAiD,wBAAwB,KAAG,MAKnG,CAAC;AAqFF;;;GAGG;AACH,QAAA,MAAM,WAAW;YAC6B,WAAW;cAAY,MAAM;;;eAClC,SAAS;kBAAgB,YAAY;MAC3E,QAAQ,MAAM,CAShB,CAAC;AAiBF,UAAU,wCAAwC;IAChD,UAAU,EAAE,WAAW,GAAG,mBAAmB,CAAC;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,QAAA,MAAM,YAAY,6DAMf,wCAAwC,KAAG,QAAQ,kBAAkB,CAmDvE,CAAC;AAEF,UAAU,mBAAmB;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC1B;AACD,iBAAe,aAAa,CAAC,MAAM,EAAE,mBAAmB,iBAGvD;AA4CD,KAAK,iBAAiB,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9D;;GAEG;AACH,QAAA,MAAM,sBAAsB,uDAO3B,CAAC;AAEF,OAAO,EAAC,kBAAkB,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAC,CAAC"}
+{"version":3,"file":"SessionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAC,oBAAoB,EAAC,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAC,WAAW,EAAE,4BAA4B,EAAC,MAAM,8BAA8B,CAAC;AAEvF,OAAO,EAAC,MAAM,EAAC,MAAM,SAAS,CAAC;AAE/B,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAK9C,OAAO,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAE/D,UAAU,wBAAwB;IAChC,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,KAAK,kBAAkB,GAAG;IACxB,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8GAA8G;IAC9G,QAAQ,CAAC,EAAE,oBAAoB,CAAC;CACjC,CAAC;AAEF,QAAA,MAAM,kBAAkB,yBAAwB,wBAAwB,KAAG,MAI1E,CAAC;AA6BF;;;GAGG;AACH,QAAA,MAAM,WAAW;YAC6B,WAAW;cAAY,MAAM;;;eAClC,SAAS;kBAAgB,YAAY;MAC3E,QAAQ,MAAM,CAUhB,CAAC;AAeF,UAAU,wCAAwC;IAChD,UAAU,EAAE,oBAAoB,GAAG,4BAA4B,CAAC;IAChE,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,QAAA,MAAM,YAAY,qDAKf,wCAAwC,KAAG,QAAQ,kBAAkB,CAoDvE,CAAC;AAEF,UAAU,mBAAmB;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;CAC5B;AACD,iBAAe,aAAa,CAAC,MAAM,EAAE,mBAAmB,iBAGvD;AA4CD,KAAK,iBAAiB,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9E;;GAEG;AACH,QAAA,MAAM,sBAAsB,uDAY3B,CAAC;AAEF,OAAO,EAAC,kBAAkB,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAC,CAAC"}

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

@@ -21,11 +21,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildEncryptedPayloads = exports.deleteSession = exports.initSessions = exports.initSession = exports.constructSessionId = void 0;
 const bazinga64_1 = require("bazinga64");
 const UserClientsUtil_1 = require("../../../../conversation/message/UserClientsUtil");
-const constructSessionId = ({ userId, clientId, useQualifiedIds, domain }) => {
-    const id = typeof userId === 'string' ? userId : userId.id;
-    const baseDomain = typeof userId === 'string' ? domain : userId.domain;
+const constructSessionId = ({ userId, clientId }) => {
+    const { id, domain } = userId;
     const baseId = `${id}@${clientId}`;
-    return baseDomain && useQualifiedIds ? `${baseDomain}@${baseId}` : baseId;
+    return domain ? `${domain}@${baseId}` : baseId;
 };
 exports.constructSessionId = constructSessionId;
 const isSessionId = (object) => {
@@ -43,45 +42,16 @@ const parseSessionId = (sessionId) => {
     }
     return match.groups;
 };
-const createLegacySessions = async ({ userClients, apiClient, cryptoClient, }) => {
-    const preKeyBundleMap = await apiClient.api.user.postMultiPreKeyBundles(userClients);
-    const sessions = await createSessionsFromPreKeys({
-        preKeyBundleMap,
-        useQualifiedIds: false,
-        cryptoClient,
-    });
-    return sessions;
-};
-/**
- * Create sessions for the qualified clients.
- * @param {userClientMap} map of domain to (map of user IDs to client IDs)
- */
-const createQualifiedSessions = async ({ userClientMap, domain, apiClient, cryptoClient, }) => {
-    const prekeyBundleMap = await apiClient.api.user.postQualifiedMultiPreKeyBundles({ [domain]: userClientMap });
-    const sessions = [];
-    let unknowns = {};
-    for (const domain in prekeyBundleMap) {
-        const domainUsers = prekeyBundleMap[domain];
-        const { sessions: createdSessions, unknowns: domainUnknowns } = await createSessionsFromPreKeys({
-            preKeyBundleMap: domainUsers,
-            domain,
-            useQualifiedIds: true,
-            cryptoClient,
-        });
-        sessions.push(...createdSessions);
-        unknowns = Object.assign(Object.assign({}, unknowns), domainUnknowns);
-    }
-    return { sessions, unknowns };
-};
 /**
  * Will make sure the session is available in cryptoClient
  * @param sessionId the session to init
  */
 const initSession = async ({ userId, clientId, initialPrekey }, { cryptoClient, apiClient }) => {
-    const recipients = initialPrekey ? { [userId.id]: { [clientId]: initialPrekey } } : { [userId.id]: [clientId] };
+    const recipients = initialPrekey
+        ? { [userId.domain]: { [userId.id]: { [clientId]: initialPrekey } } }
+        : { [userId.domain]: { [userId.id]: [clientId] } };
     const { sessions } = await initSessions({
         recipients,
-        domain: userId.domain,
         apiClient,
         cryptoClient,
     });
@@ -90,56 +60,55 @@ const initSession = async ({ userId, clientId, initialPrekey }, { cryptoClient,
 exports.initSession = initSession;
 /**
  * Create sessions for legacy/qualified clients (umberella function).
- * Will call createQualifiedSessions or createLegacySessions based on passed userClientMap.
  * @param {userClientMap} map of domain to (map of user IDs to client IDs) or map of user IDs containg the lists of clients
  */
-const createSessions = async ({ userClientMap, domain, apiClient, cryptoClient, logger }) => {
-    return domain
-        ? createQualifiedSessions({ userClientMap, domain, apiClient, cryptoClient, logger })
-        : createLegacySessions({
-            userClients: userClientMap,
-            apiClient,
-            cryptoClient,
-        });
+const createSessions = async ({ recipients, apiClient, cryptoClient }) => {
+    const prekeyBundleMap = await apiClient.api.user.postMultiPreKeyBundles(recipients);
+    return await createSessionsFromPreKeys({
+        recipients: prekeyBundleMap,
+        cryptoClient,
+    });
 };
 /**
  * Will make sure all the sessions need to encrypt for those user/clients pair are set
  */
-const initSessions = async ({ recipients, domain = '', apiClient, cryptoClient, logger, }) => {
+const initSessions = async ({ recipients, apiClient, cryptoClient, logger, }) => {
+    var _a, _b, _c;
     const missingClients = {};
     const missingClientsWithPrekeys = {};
     const existingSessions = [];
-    const users = (0, UserClientsUtil_1.flattenUserClients)(recipients, domain);
+    const users = (0, UserClientsUtil_1.flattenQualifiedUserClients)(recipients);
     for (const user of users) {
         const { userId, data } = user;
         const clients = Array.isArray(data) ? data : Object.keys(data);
         for (const clientId of clients) {
-            const sessionId = constructSessionId({ userId, clientId, useQualifiedIds: !!domain });
+            const sessionId = constructSessionId({ userId, clientId });
             if (await cryptoClient.sessionExists(sessionId)) {
                 existingSessions.push(sessionId);
                 continue;
             }
             if (!Array.isArray(data)) {
-                missingClientsWithPrekeys[userId.id] = missingClientsWithPrekeys[userId.id] || {};
-                missingClientsWithPrekeys[userId.id][clientId] = data[clientId];
+                const domainMissingWithPrekey = (_a = missingClientsWithPrekeys[userId.domain]) !== null && _a !== void 0 ? _a : {};
+                domainMissingWithPrekey[userId.id] = (_b = domainMissingWithPrekey[userId.id]) !== null && _b !== void 0 ? _b : {};
+                domainMissingWithPrekey[userId.id][clientId] = data[clientId];
+                missingClientsWithPrekeys[userId.domain] = domainMissingWithPrekey;
                 continue;
             }
-            missingClients[userId.id] = missingClients[userId.id] || [];
-            missingClients[userId.id].push(clientId);
+            const domainMissing = (_c = missingClients[userId.domain]) !== null && _c !== void 0 ? _c : {};
+            domainMissing[userId.id] = domainMissing[userId.id] || [];
+            domainMissing[userId.id].push(clientId);
+            missingClients[userId.domain] = domainMissing;
         }
     }
     const { sessions: prekeyCreated, unknowns: prekeyUnknows } = Object.keys(missingClientsWithPrekeys).length > 0
         ? await createSessionsFromPreKeys({
-            preKeyBundleMap: missingClientsWithPrekeys,
-            domain,
-            useQualifiedIds: !!domain,
+            recipients: missingClientsWithPrekeys,
             cryptoClient,
         })
         : { sessions: [], unknowns: {} };
     const { sessions: created, unknowns } = Object.keys(missingClients).length > 0
         ? await createSessions({
-            userClientMap: missingClients,
-            domain,
+            recipients: missingClients,
             apiClient,
             cryptoClient,
             logger,
@@ -157,23 +126,28 @@ async function deleteSession(params) {
     await params.cryptoClient.deleteSession(sessionId);
 }
 exports.deleteSession = deleteSession;
-const createSessionsFromPreKeys = async ({ preKeyBundleMap, domain = '', useQualifiedIds, cryptoClient, }) => {
+const createSessionsFromPreKeys = async ({ recipients, cryptoClient, }) => {
+    var _a, _b;
     const sessions = [];
     const unknowns = {};
-    for (const userId in preKeyBundleMap) {
-        const userClients = preKeyBundleMap[userId];
-        for (const clientId in userClients) {
-            const sessionId = constructSessionId({ userId, clientId, domain, useQualifiedIds });
-            const prekey = userClients[clientId];
-            if (!prekey) {
-                unknowns[userId] = unknowns[userId] || [];
-                unknowns[userId].push(clientId);
-                continue;
+    for (const domain in recipients) {
+        for (const userId in recipients[domain]) {
+            const userClients = recipients[domain][userId];
+            for (const clientId in userClients) {
+                const sessionId = constructSessionId({ userId: { id: userId, domain }, clientId });
+                const prekey = userClients[clientId];
+                if (!prekey) {
+                    const domainUnknowns = (_a = unknowns[domain]) !== null && _a !== void 0 ? _a : {};
+                    domainUnknowns[userId] = (_b = domainUnknowns[userId]) !== null && _b !== void 0 ? _b : [];
+                    domainUnknowns[userId].push(clientId);
+                    unknowns[domain] = domainUnknowns;
+                    continue;
+                }
+                const prekeyBuffer = bazinga64_1.Decoder.fromBase64(prekey.key).asBytes;
+                await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
+                await cryptoClient.saveSession(sessionId);
+                sessions.push(sessionId);
             }
-            const prekeyBuffer = bazinga64_1.Decoder.fromBase64(prekey.key).asBytes;
-            await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
-            await cryptoClient.saveSession(sessionId);
-            sessions.push(sessionId);
         }
     }
     return { sessions, unknowns };
@@ -183,10 +157,15 @@ const createSessionsFromPreKeys = async ({ preKeyBundleMap, domain = '', useQual
  */
 const buildEncryptedPayloads = (payloads) => {
     return [...payloads].reduce((acc, [sessionId, payload]) => {
-        var _a;
-        const { userId, clientId } = parseSessionId(sessionId);
-        acc[userId] = (_a = acc[userId]) !== null && _a !== void 0 ? _a : {};
-        acc[userId][clientId] = payload;
+        var _a, _b;
+        const { userId, domain, clientId } = parseSessionId(sessionId);
+        if (!domain) {
+            throw new Error('Invalid session ID');
+        }
+        const domainPayloads = (_a = acc[domain]) !== null && _a !== void 0 ? _a : {};
+        domainPayloads[userId] = (_b = domainPayloads[userId]) !== null && _b !== void 0 ? _b : {};
+        domainPayloads[userId][clientId] = payload;
+        acc[domain] = domainPayloads;
         return acc;
     }, {});
 };

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

@@ -41,40 +41,20 @@ describe('SessionHandler', () => {
     describe('constructSessionId', () => {
         describe('constructs a session ID', () => {
             it('without a domain', () => {
-                const sessionId = (0, SessionHandler_1.constructSessionId)({ userId: 'user-id', clientId: 'client-id', useQualifiedIds: true });
+                const sessionId = (0, SessionHandler_1.constructSessionId)({ userId: { id: 'user-id', domain: '' }, clientId: 'client-id' });
                 expect(sessionId).toBe('user-id@client-id');
             });
             it('with a domain', () => {
-                const sessionId = (0, SessionHandler_1.constructSessionId)({
-                    userId: 'user-id',
-                    clientId: 'client-id',
-                    domain: 'domain',
-                    useQualifiedIds: true,
-                });
-                expect(sessionId).toBe('domain@user-id@client-id');
-            });
-            it('with a domain and useQualifiedIds', () => {
-                const sessionId = (0, SessionHandler_1.constructSessionId)({
-                    userId: 'user-id',
-                    clientId: 'client-id',
-                    domain: 'domain',
-                    useQualifiedIds: true,
-                });
-                expect(sessionId).toBe('domain@user-id@client-id');
-            });
-            it('with a qualified ID', () => {
                 const sessionId = (0, SessionHandler_1.constructSessionId)({
                     userId: { id: 'user-id', domain: 'domain' },
                     clientId: 'client-id',
-                    useQualifiedIds: true,
                 });
                 expect(sessionId).toBe('domain@user-id@client-id');
             });
-            it('with a qualified ID and useQualifiedIds', () => {
+            it('with a qualified ID', () => {
                 const sessionId = (0, SessionHandler_1.constructSessionId)({
                     userId: { id: 'user-id', domain: 'domain' },
                     clientId: 'client-id',
-                    useQualifiedIds: true,
                 });
                 expect(sessionId).toBe('domain@user-id@client-id');
             });
@@ -91,12 +71,11 @@ describe('SessionHandler', () => {
             const clientId = 'client1';
             jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
             jest
-                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
+                .spyOn(apiClient.api.user, 'postMultiPreKeyBundles')
                 .mockResolvedValue({ domain: generatePrekeys(userId, [clientId]) });
             const sessionId = (0, SessionHandler_1.constructSessionId)({
                 userId,
                 clientId,
-                useQualifiedIds: true,
             });
             await (0, SessionHandler_1.initSession)({ userId, clientId }, { apiClient, cryptoClient });
             expect(cryptoClient.sessionFromPrekey).toHaveBeenCalledWith(sessionId, expect.any(Object));
@@ -105,12 +84,11 @@ describe('SessionHandler', () => {
             const userId = { id: 'user1', domain: 'domain' };
             const clientId = 'client1';
             jest
-                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
+                .spyOn(apiClient.api.user, 'postMultiPreKeyBundles')
                 .mockResolvedValue({ domain: generatePrekeys(userId, [clientId]) });
             const sessionId = (0, SessionHandler_1.constructSessionId)({
                 userId,
                 clientId,
-                useQualifiedIds: true,
             });
             await (0, SessionHandler_1.initSession)({ userId, clientId }, { apiClient, cryptoClient });
             expect(cryptoClient.sessionFromPrekey).toHaveBeenCalledWith(sessionId, expect.any(Object));
@@ -126,14 +104,15 @@ describe('SessionHandler', () => {
                 'missing-user1': ['client1'],
                 'missing-user2': ['client1', 'client2'],
             };
-            jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockResolvedValue({});
-            jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue(Object.assign(Object.assign({}, generatePrekeys({ id: 'missing-user1', domain: '' }, ['client1'])), generatePrekeys({ id: 'missing-user2', domain: '' }, ['client1', 'client2'])));
+            jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue({
+                domain: Object.assign(Object.assign({}, generatePrekeys({ id: 'missing-user1', domain: '' }, ['client1'])), generatePrekeys({ id: 'missing-user2', domain: '' }, ['client1', 'client2'])),
+            });
             jest
                 .spyOn(cryptoClient, 'sessionExists')
                 .mockImplementation(sessionId => Promise.resolve(sessionId.includes('missing')));
             const sessionFromPrekeySpy = jest.spyOn(cryptoClient, 'sessionFromPrekey');
             const { sessions } = await (0, SessionHandler_1.initSessions)({
-                recipients: Object.assign(Object.assign({}, existingUserClients), missingUserClients),
+                recipients: { domain: Object.assign(Object.assign({}, existingUserClients), missingUserClients) },
                 apiClient,
                 cryptoClient,
             });
@@ -144,16 +123,30 @@ describe('SessionHandler', () => {
             const userClients = {
                 'existing-user1': ['client1', 'deleteclient'],
             };
-            const allKeys = generatePrekeys({ id: 'existing-user1', domain: '' }, ['client1']);
-            allKeys['existing-user1']['deleteclient'] = null;
+            const allKeys = { domain: generatePrekeys({ id: 'existing-user1', domain: 'domain' }, ['client1']) };
+            allKeys['domain']['existing-user1']['deleteclient'] = null;
             jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue(allKeys);
+            const { sessions, unknowns } = await (0, SessionHandler_1.initSessions)({
+                recipients: { domain: userClients },
+                apiClient,
+                cryptoClient,
+            });
+            expect(sessions).toEqual(['domain@existing-user1@client1']);
+            expect(unknowns).toEqual({ domain: { 'existing-user1': ['deleteclient'] } });
+        });
+        it('initializes sessions across multiple domains', async () => {
+            const userClients = {
+                domain1: { 'existing-user1': ['client11'] },
+                domain2: { 'existing-user2': ['client21'] },
+            };
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(true);
             const { sessions, unknowns } = await (0, SessionHandler_1.initSessions)({
                 recipients: userClients,
                 apiClient,
                 cryptoClient,
             });
-            expect(sessions).toEqual(['existing-user1@client1']);
-            expect(unknowns).toEqual({ 'existing-user1': ['deleteclient'] });
+            expect(sessions).toEqual(['domain1@existing-user1@client11', 'domain2@existing-user2@client21']);
+            expect(unknowns).toBeUndefined();
         });
     });
 });

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

@@ -1,10 +1,9 @@
 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';
+import { QualifiedUserClients } from '@wireapp/api-client/lib/conversation';
+import { QualifiedId, QualifiedUserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
 import { GenericMessage } from '@wireapp/protocol-messaging';
 import { MessageSendingOptions } from '../../../conversation';
-export type FederatedMessageParams = {
-    federated: true;
+export type MessageParams = {
     sendingClientId: string;
     recipients: QualifiedUserClients | QualifiedUserPreKeyBundleMap;
     plainText: Uint8Array;
@@ -14,22 +13,14 @@ export type FederatedMessageParams = {
         reportMissing: boolean | QualifiedId[] | undefined;
     };
 };
-export type MessageParams = Omit<FederatedMessageParams, 'recipients' | 'options' | 'federated'> & {
-    federated: false;
-    recipients: UserClients | UserPreKeyBundleMap;
-    options: Omit<FederatedMessageParams['options'], 'reportMissing'> & {
-        reportMissing: boolean | string[] | undefined;
-    };
-};
 interface GetGenericMessageParamsParams {
     sendingClientId: string;
     conversationId: QualifiedId;
     genericMessage: GenericMessage;
     options: MessageSendingOptions;
-    useQualifiedIds: boolean;
     apiClient: APIClient;
 }
-type GetGenericMessageParamsReturnType = Promise<MessageParams | FederatedMessageParams>;
-declare const getGenericMessageParams: ({ sendingClientId, conversationId, genericMessage, options: { targetMode, userIds, nativePush }, useQualifiedIds, apiClient, }: GetGenericMessageParamsParams) => GetGenericMessageParamsReturnType;
+type GetGenericMessageParamsReturnType = Promise<MessageParams>;
+declare const getGenericMessageParams: ({ sendingClientId, conversationId, genericMessage, options: { targetMode, userIds, nativePush }, apiClient, }: GetGenericMessageParamsParams) => GetGenericMessageParamsReturnType;
 export { getGenericMessageParams };
 //# sourceMappingURL=getGenericMessageParams.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getGenericMessageParams.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/Utility/getGenericMessageParams.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;AAE5G,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAK3D,OAAO,EAAoB,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAG/E,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,IAAI,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,oBAAoB,GAAG,4BAA4B,CAAC;IAChE,SAAS,EAAE,UAAU,CAAC;IACtB,OAAO,EAAE;QACP,cAAc,EAAE,WAAW,CAAC;QAC5B,UAAU,EAAE,OAAO,GAAG,SAAS,CAAC;QAChC,aAAa,EAAE,OAAO,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC;KACpD,CAAC;CACH,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,EAAE,YAAY,GAAG,SAAS,GAAG,WAAW,CAAC,GAAG;IACjG,SAAS,EAAE,KAAK,CAAC;IACjB,UAAU,EAAE,WAAW,GAAG,mBAAmB,CAAC;IAC9C,OAAO,EAAE,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC,GAAG;QAClE,aAAa,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;KAC/C,CAAC;CACH,CAAC;AACF,UAAU,6BAA6B;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC;IAC5B,cAAc,EAAE,cAAc,CAAC;IAC/B,OAAO,EAAE,qBAAqB,CAAC;IAC/B,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;CACtB;AACD,KAAK,iCAAiC,GAAG,OAAO,CAAC,aAAa,GAAG,sBAAsB,CAAC,CAAC;AAEzF,QAAA,MAAM,uBAAuB,mIAO1B,6BAA6B,sCAyD/B,CAAC;AAEF,OAAO,EAAC,uBAAuB,EAAC,CAAC"}
+{"version":3,"file":"getGenericMessageParams.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/Utility/getGenericMessageParams.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AAC5D,OAAO,EAAC,oBAAoB,EAAC,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAC,WAAW,EAAE,4BAA4B,EAAC,MAAM,8BAA8B,CAAC;AAEvF,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAK3D,OAAO,EAAoB,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAG/E,MAAM,MAAM,aAAa,GAAG;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,oBAAoB,GAAG,4BAA4B,CAAC;IAChE,SAAS,EAAE,UAAU,CAAC;IACtB,OAAO,EAAE;QACP,cAAc,EAAE,WAAW,CAAC;QAC5B,UAAU,EAAE,OAAO,GAAG,SAAS,CAAC;QAChC,aAAa,EAAE,OAAO,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC;KACpD,CAAC;CACH,CAAC;AACF,UAAU,6BAA6B;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC;IAC5B,cAAc,EAAE,cAAc,CAAC;IAC/B,OAAO,EAAE,qBAAqB,CAAC;IAC/B,SAAS,EAAE,SAAS,CAAC;CACtB;AACD,KAAK,iCAAiC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AAEhE,QAAA,MAAM,uBAAuB,kHAM1B,6BAA6B,sCA0B/B,CAAC;AAEF,OAAO,EAAC,uBAAuB,EAAC,CAAC"}

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

@@ -24,56 +24,24 @@ const Recipients_1 = require("./Recipients");
 const UserIds_1 = require("./UserIds");
 const conversation_1 = require("../../../conversation");
 const util_1 = require("../../../util");
-const getGenericMessageParams = async ({ sendingClientId, conversationId, genericMessage, options: { targetMode = conversation_1.MessageTargetMode.NONE, userIds, nativePush }, useQualifiedIds, apiClient, }) => {
+const getGenericMessageParams = async ({ sendingClientId, conversationId, genericMessage, options: { targetMode = conversation_1.MessageTargetMode.NONE, userIds, nativePush }, apiClient, }) => {
     const plainText = protocol_messaging_1.GenericMessage.encode(genericMessage).finish();
     if (targetMode !== conversation_1.MessageTargetMode.NONE && !userIds) {
         throw new Error('Cannot send targetted message when no userIds are given');
     }
-    if (conversationId.domain && useQualifiedIds) {
-        if ((0, util_1.isStringArray)(userIds) || (0, util_1.isUserClients)(userIds)) {
-            throw new Error('Invalid userIds option for sending to federated backend');
-        }
-        const recipients = await (0, Recipients_1.getQualifiedRecipientsForConversation)({ apiClient, conversationId, userIds });
-        let reportMissing;
-        if (targetMode === conversation_1.MessageTargetMode.NONE) {
-            reportMissing = (0, util_1.isQualifiedUserClients)(userIds); // we want to check mismatch in case the consumer gave an exact list of users/devices
-        }
-        else if (targetMode === conversation_1.MessageTargetMode.USERS) {
-            reportMissing = (0, UserIds_1.extractQualifiedUserIds)({ userIds });
-        }
-        else {
-            // in case the message is fully targetted at user/client pairs, we do not want to report the missing clients or users at all
-            reportMissing = false;
-        }
-        return {
-            federated: true,
-            sendingClientId,
-            recipients,
-            plainText,
-            options: {
-                conversationId,
-                nativePush,
-                reportMissing,
-            },
-        };
-    }
-    if ((0, util_1.isQualifiedIdArray)(userIds) || (0, util_1.isQualifiedUserClients)(userIds)) {
-        throw new Error('Invalid userIds option for sending');
-    }
     const recipients = await (0, Recipients_1.getRecipientsForConversation)({ apiClient, conversationId, userIds });
     let reportMissing;
     if (targetMode === conversation_1.MessageTargetMode.NONE) {
-        reportMissing = (0, util_1.isUserClients)(userIds); // we want to check mismatch in case the consumer gave an exact list of users/devices
+        reportMissing = (0, util_1.isQualifiedUserClients)(userIds); // we want to check mismatch in case the consumer gave an exact list of users/devices
     }
     else if (targetMode === conversation_1.MessageTargetMode.USERS) {
-        reportMissing = (0, UserIds_1.extractUserIds)({ userIds });
+        reportMissing = (0, UserIds_1.extractQualifiedUserIds)({ userIds });
     }
     else {
         // in case the message is fully targetted at user/client pairs, we do not want to report the missing clients or users at all
         reportMissing = false;
     }
     return {
-        federated: false,
         sendingClientId,
         recipients,
         plainText,

package/lib/user/UserService.d.ts

@@ -1,24 +1,9 @@
 import { QualifiedId, User } from '@wireapp/api-client/lib/user/';
 import { APIClient } from '@wireapp/api-client';
-import { AvailabilityType, BroadcastService } from '../broadcast/';
-import { ConnectionService } from '../connection';
 export declare class UserService {
     private readonly apiClient;
-    private readonly broadcastService;
-    private readonly connectionService;
-    constructor(apiClient: APIClient, broadcastService: BroadcastService, connectionService: ConnectionService);
+    constructor(apiClient: APIClient);
     getUser(userId: string | QualifiedId): Promise<User>;
     getUsers(userIds: string[] | QualifiedId[]): Promise<User[]>;
-    /**
-     * Sends a availability update to members of the same team
-     * @param teamId
-     * @param type
-     * @param options.sendAll=false will broadcast the message to all the members of the team (instead of just direct connections). Should be avoided in a big team
-     * @param options.sendAsProtobuf=false
-     */
-    setAvailability(teamId: string, type: AvailabilityType, { sendAll, sendAsProtobuf }?: {
-        sendAll?: boolean | undefined;
-        sendAsProtobuf?: boolean | undefined;
-    }): Promise<void>;
 }
 //# sourceMappingURL=UserService.d.ts.map

package/lib/user/UserService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UserService.d.ts","sourceRoot":"","sources":["../../src/user/UserService.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,WAAW,EAAE,IAAI,EAAsB,MAAM,+BAA+B,CAAC;AAErF,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAG9C,OAAO,EAAC,gBAAgB,EAAE,gBAAgB,EAAC,MAAM,eAAe,CAAC;AACjE,OAAO,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAKhD,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IACpD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;gBAE1C,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB;IAMnG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9C,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IASzE;;;;;;OAMG;IACU,eAAe,CAC1B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,gBAAgB,EACtB,EAAC,OAAe,EAAE,cAAsB,EAAC;;;KAAK,GAC7C,OAAO,CAAC,IAAI,CAAC;CAuCjB"}
+{"version":3,"file":"UserService.d.ts","sourceRoot":"","sources":["../../src/user/UserService.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,WAAW,EAAE,IAAI,EAAC,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAI9C,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;gBAE1B,SAAS,EAAE,SAAS;IAIzB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9C,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;CAQ1E"}

package/lib/user/UserService.js

@@ -19,16 +19,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserService = void 0;
-const connection_1 = require("@wireapp/api-client/lib/connection");
-const protocol_messaging_1 = require("@wireapp/protocol-messaging");
-const MessageBuilder_1 = require("../conversation/message/MessageBuilder");
-const PreKeyBundle_1 = require("../messagingProtocols/proteus/Utility/PreKeyBundle");
 const TypePredicateUtil_1 = require("../util/TypePredicateUtil");
 class UserService {
-    constructor(apiClient, broadcastService, connectionService) {
+    constructor(apiClient) {
         this.apiClient = apiClient;
-        this.broadcastService = broadcastService;
-        this.connectionService = connectionService;
     }
     getUser(userId) {
         return this.apiClient.api.user.getUser(userId);
@@ -41,41 +35,5 @@ class UserService {
             ? this.apiClient.api.user.postListUsers({ qualified_ids: userIds })
             : this.apiClient.api.user.getUsers({ ids: userIds });
     }
-    /**
-     * Sends a availability update to members of the same team
-     * @param teamId
-     * @param type
-     * @param options.sendAll=false will broadcast the message to all the members of the team (instead of just direct connections). Should be avoided in a big team
-     * @param options.sendAsProtobuf=false
-     */
-    async setAvailability(teamId, type, { sendAll = false, sendAsProtobuf = false } = {}) {
-        // Get pre-key bundles for members of your own team
-        const preKeyBundlesFromTeam = await this.broadcastService.getPreKeyBundlesFromTeam(teamId, false, !sendAll);
-        // Get pre-key bundles for all of your other 1:1 connections
-        const connections = await this.connectionService.getConnections();
-        const acceptedConnections = connections.filter(connection => connection.status === connection_1.ConnectionStatus.ACCEPTED);
-        const preKeyBundlePromises = acceptedConnections.map(connection => {
-            const mappedConnection = {
-                userId: connection.to,
-                conversationId: connection.conversation,
-            };
-            return (0, PreKeyBundle_1.getPreKeyBundleMap)({
-                apiClient: this.apiClient,
-                conversationId: { id: mappedConnection.conversationId, domain: '' },
-                userIds: [mappedConnection.userId],
-            });
-        });
-        const preKeyBundlesFromConnections = await Promise.all(preKeyBundlePromises);
-        // Merge pre-key bundles
-        const allPreKeyBundles = preKeyBundlesFromConnections.reduce((accumulator, preKeyBundleMap) => {
-            return Object.assign(Object.assign({}, accumulator), preKeyBundleMap);
-        }, preKeyBundlesFromTeam);
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            availability: new protocol_messaging_1.Availability({ type }),
-            messageId: (0, MessageBuilder_1.createId)(),
-        });
-        // Broadcast availability status to your team members & external 1:1 connections
-        await this.broadcastService.broadcastGenericMessage(genericMessage, allPreKeyBundles, sendAsProtobuf);
-    }
 }
 exports.UserService = UserService;

package/package.json

@@ -11,7 +11,7 @@
     "./lib/cryptography/AssetCryptography/crypto.node": "./lib/cryptography/AssetCryptography/crypto.browser.js"
   },
   "dependencies": {
-    "@wireapp/api-client": "^22.17.1",
+    "@wireapp/api-client": "^23.0.0",
     "@wireapp/commons": "^5.0.4",
     "@wireapp/core-crypto": "0.6.2",
     "@wireapp/cryptobox": "12.8.0",
@@ -60,6 +60,6 @@
     "test:coverage": "jest --coverage",
     "watch": "tsc --watch"
   },
-  "version": "38.15.2",
-  "gitHead": "98e83e77041b5e89ba22052b0e383586c14aa746"
+  "version": "39.0.0",
+  "gitHead": "5e86fc700f348bd1f6d477b5eae88bb6d8bb5fb0"
 }