@wireapp/core 40.5.0 → 40.5.2-1

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

@@ -0,0 +1,2 @@
+export * from './PreKeyBundle';
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,35 @@
+"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/.
+ *
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PreKeyBundle"), exports);

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

@@ -1,11 +1,17 @@
 import { APIClient } from '@wireapp/api-client/lib/APIClient';
-import { QualifiedUserClients } from '@wireapp/api-client/lib/conversation';
-import { QualifiedId } from '@wireapp/api-client/lib/user';
+import { QualifiedUserClients, UserClients } from '@wireapp/api-client/lib/conversation';
+import { QualifiedId, QualifiedUserPreKeyBundleMap, UserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
 interface GetRecipientsForConversationQualifiedParams {
     apiClient: APIClient;
     conversationId: QualifiedId;
     userIds?: QualifiedId[] | QualifiedUserClients;
 }
-declare const getRecipientsForConversation: ({ apiClient, conversationId, userIds, }: GetRecipientsForConversationQualifiedParams) => Promise<QualifiedUserClients>;
-export { getRecipientsForConversation };
+declare const getQualifiedRecipientsForConversation: ({ apiClient, conversationId, userIds, }: GetRecipientsForConversationQualifiedParams) => Promise<QualifiedUserClients | QualifiedUserPreKeyBundleMap>;
+interface GetRecipientsForConversationParams {
+    apiClient: APIClient;
+    conversationId: QualifiedId;
+    userIds?: string[] | UserClients;
+}
+declare const getRecipientsForConversation: ({ apiClient, conversationId, userIds, }: GetRecipientsForConversationParams) => Promise<UserClients | UserPreKeyBundleMap>;
+export { getQualifiedRecipientsForConversation, getRecipientsForConversation };
 //# sourceMappingURL=Recipients.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Recipients.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/Utility/Recipients.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AAE5D,OAAO,EAAC,oBAAoB,EAAC,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AAczD,UAAU,2CAA2C;IACnD,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,WAAW,CAAC;IAC5B,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,oBAAoB,CAAC;CAChD;AAED,QAAA,MAAM,4BAA4B,4CAI/B,2CAA2C,KAAG,QAAQ,oBAAoB,CAW5E,CAAC;AAEF,OAAO,EAAC,4BAA4B,EAAC,CAAC"}
+{"version":3,"file":"Recipients.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/Utility/Recipients.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;AAO5G,UAAU,2CAA2C;IACnD,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,WAAW,CAAC;IAC5B,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,oBAAoB,CAAC;CAChD;AAED,QAAA,MAAM,qCAAqC,4CAIxC,2CAA2C,KAAG,QAAQ,oBAAoB,GAAG,4BAA4B,CAO3G,CAAC;AAEF,UAAU,kCAAkC;IAC1C,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,WAAW,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,CAAC;CAClC;AACD,QAAA,MAAM,4BAA4B,4CAI/B,kCAAkC,KAAG,QAAQ,WAAW,GAAG,mBAAmB,CAShF,CAAC;AAEF,OAAO,EAAC,qCAAqC,EAAE,4BAA4B,EAAC,CAAC"}

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

@@ -18,26 +18,26 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRecipientsForConversation = void 0;
+exports.getRecipientsForConversation = exports.getQualifiedRecipientsForConversation = void 0;
+const PreKeyBundle_1 = require("./PreKeyBundle/PreKeyBundle");
 const getConversationQualifiedMembers_1 = require("../../../conversation/ConversationService/Utility/getConversationQualifiedMembers");
-const UserClientsUtil_1 = require("../../../conversation/message/UserClientsUtil");
 const util_1 = require("../../../util");
-function toQualifiedUserClients(publicClients) {
-    const userList = (0, UserClientsUtil_1.flattenUserMap)(publicClients).map(({ userId, data: clientInfo }) => ({
-        userId,
-        data: clientInfo.map(client => client.id),
-    }));
-    return (0, UserClientsUtil_1.nestUsersList)(userList);
-}
-const getRecipientsForConversation = async ({ apiClient, conversationId, userIds, }) => {
+const getQualifiedRecipientsForConversation = async ({ apiClient, conversationId, userIds, }) => {
     if ((0, util_1.isQualifiedUserClients)(userIds)) {
         return userIds;
     }
-    const hasTargetUsers = userIds && Object.keys(userIds).length > 0;
-    const recipientIds = hasTargetUsers
-        ? userIds
-        : await (0, getConversationQualifiedMembers_1.getConversationQualifiedMembers)({ apiClient: apiClient, conversationId });
-    const allClients = await apiClient.api.user.postListClients({ qualified_users: recipientIds });
-    return toQualifiedUserClients(allClients.qualified_user_map);
+    const recipientIds = userIds || (await (0, getConversationQualifiedMembers_1.getConversationQualifiedMembers)({ apiClient: apiClient, conversationId }));
+    return (0, PreKeyBundle_1.getQualifiedPreKeyBundle)({ apiClient, userIds: recipientIds });
+};
+exports.getQualifiedRecipientsForConversation = getQualifiedRecipientsForConversation;
+const getRecipientsForConversation = async ({ apiClient, conversationId, userIds, }) => {
+    if ((0, util_1.isUserClients)(userIds)) {
+        return userIds;
+    }
+    return (0, PreKeyBundle_1.getPreKeyBundleMap)({
+        apiClient: apiClient,
+        conversationId,
+        userIds,
+    });
 };
 exports.getRecipientsForConversation = getRecipientsForConversation;

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

@@ -1,23 +1,16 @@
 import { PreKey } from '@wireapp/api-client/lib/auth';
-import { QualifiedUserClients } from '@wireapp/api-client/lib/conversation';
-import { QualifiedId, QualifiedUserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
+import { UserClients } from '@wireapp/api-client/lib/conversation';
+import { QualifiedId, UserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
 import { Logger } from 'logdown';
 import { APIClient } from '@wireapp/api-client';
 import { CryptoClient } from '../../ProteusService/CryptoClient';
 interface ConstructSessionIdParams {
-    userId: QualifiedId;
+    userId: string | 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?: QualifiedUserClients;
-    /** clients for which we had problem fetch prekeys (federated server down) */
-    failed?: QualifiedId[];
-};
-declare const constructSessionId: ({ userId, clientId }: ConstructSessionIdParams) => string;
+declare const constructSessionId: ({ userId, clientId, useQualifiedIds, domain }: ConstructSessionIdParams) => string;
 /**
  * Will make sure the session is available in cryptoClient
  * @param sessionId the session to init
@@ -31,7 +24,8 @@ declare const initSession: ({ userId, clientId, initialPrekey }: {
     cryptoClient: CryptoClient;
 }) => Promise<string>;
 interface GetSessionsAndClientsFromRecipientsProps {
-    recipients: QualifiedUserClients | QualifiedUserPreKeyBundleMap;
+    recipients: UserClients | UserPreKeyBundleMap;
+    domain?: string;
     apiClient: APIClient;
     cryptoClient: CryptoClient;
     logger?: Logger;
@@ -39,14 +33,15 @@ interface GetSessionsAndClientsFromRecipientsProps {
 /**
  * Will make sure all the sessions need to encrypt for those user/clients pair are set
  */
-declare const initSessions: ({ recipients, apiClient, cryptoClient, logger, }: GetSessionsAndClientsFromRecipientsProps) => Promise<InitSessionsResult>;
+declare const initSessions: ({ recipients, domain, apiClient, cryptoClient, logger, }: GetSessionsAndClientsFromRecipientsProps) => Promise<string[]>;
 interface DeleteSessionParams {
     userId: QualifiedId;
     clientId: string;
     cryptoClient: CryptoClient;
+    useQualifiedIds: boolean;
 }
 declare function deleteSession(params: DeleteSessionParams): Promise<void>;
-type EncryptedPayloads<T> = Record<string, Record<string, Record<string, T>>>;
+type EncryptedPayloads<T> = 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,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;IAChC,6EAA6E;IAC7E,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;CACxB,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;AAqBF,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,CAwDvE,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"}
+{"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,QAAA,MAAM,kBAAkB,kDAAiD,wBAAwB,KAAG,MAKnG,CAAC;AAuFF;;;GAGG;AACH,QAAA,MAAM,WAAW;YAC6B,WAAW;cAAY,MAAM;;;eAClC,SAAS;kBAAgB,YAAY;MAC3E,QAAQ,MAAM,CAmBhB,CAAC;AAyBF,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,MAAM,EAAE,CAgC7D,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;AA+CD,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"}

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

@@ -21,10 +21,11 @@ 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 }) => {
-    const { id, domain } = userId;
+const constructSessionId = ({ userId, clientId, useQualifiedIds, domain }) => {
+    const id = typeof userId === 'string' ? userId : userId.id;
+    const baseDomain = typeof userId === 'string' ? domain : userId.domain;
     const baseId = `${id}@${clientId}`;
-    return domain ? `${domain}@${baseId}` : baseId;
+    return baseDomain && useQualifiedIds ? `${baseDomain}@${baseId}` : baseId;
 };
 exports.constructSessionId = constructSessionId;
 const isSessionId = (object) => {
@@ -42,16 +43,55 @@ const parseSessionId = (sessionId) => {
     }
     return match.groups;
 };
+const createLegacySessions = async ({ userClients, apiClient, cryptoClient, logger, }) => {
+    const preKeyBundleMap = await apiClient.api.user.postMultiPreKeyBundles(userClients);
+    const sessions = await createSessionsFromPreKeys({
+        preKeyBundleMap,
+        useQualifiedIds: false,
+        cryptoClient,
+        logger,
+    });
+    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, logger, }) => {
+    const prekeyBundleMap = await apiClient.api.user.postQualifiedMultiPreKeyBundles({ [domain]: userClientMap });
+    const sessions = [];
+    for (const domain in prekeyBundleMap) {
+        const domainUsers = prekeyBundleMap[domain];
+        const domainSessions = await createSessionsFromPreKeys({
+            preKeyBundleMap: domainUsers,
+            domain,
+            useQualifiedIds: true,
+            cryptoClient,
+            logger,
+        });
+        sessions.push(...domainSessions);
+    }
+    return sessions;
+};
 /**
  * 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.domain]: { [userId.id]: { [clientId]: initialPrekey } } }
-        : { [userId.domain]: { [userId.id]: [clientId] } };
-    const { sessions } = await initSessions({
-        recipients,
+    const sessionId = constructSessionId({ userId, clientId, useQualifiedIds: !!userId.domain });
+    const sessionExists = await cryptoClient.sessionExists(sessionId);
+    if (sessionExists) {
+        return sessionId;
+    }
+    if (initialPrekey) {
+        const prekeyBuffer = bazinga64_1.Decoder.fromBase64(initialPrekey.key).asBytes;
+        await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
+        await cryptoClient.saveSession(sessionId);
+        return sessionId;
+    }
+    const sessions = await initSessions({
+        recipients: { [userId.id]: [clientId] },
+        domain: userId.domain,
         apiClient,
         cryptoClient,
     });
@@ -60,67 +100,51 @@ 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 ({ recipients, apiClient, cryptoClient }) => {
-    const { qualified_user_client_prekeys: prekeysBundle, failed_to_list: failed } = await apiClient.api.user.postMultiPreKeyBundles(recipients);
-    const result = await createSessionsFromPreKeys({
-        recipients: prekeysBundle,
+const createSessions = async ({ userClientMap, domain, apiClient, cryptoClient, logger, }) => {
+    if (domain) {
+        return await createQualifiedSessions({ userClientMap, domain, apiClient, cryptoClient, logger });
+    }
+    return await createLegacySessions({
+        userClients: userClientMap,
+        apiClient,
         cryptoClient,
+        logger,
     });
-    return Object.assign(Object.assign({}, result), { failed: (failed === null || failed === void 0 ? void 0 : failed.length) ? failed : undefined });
 };
 /**
  * Will make sure all the sessions need to encrypt for those user/clients pair are set
  */
-const initSessions = async ({ recipients, apiClient, cryptoClient, logger, }) => {
-    var _a, _b, _c;
-    const missingClients = {};
-    const missingClientsWithPrekeys = {};
+const initSessions = async ({ recipients, domain = '', apiClient, cryptoClient, logger, }) => {
+    const missingUserClients = {};
     const existingSessions = [];
-    const users = (0, UserClientsUtil_1.flattenUserMap)(recipients);
+    const users = (0, UserClientsUtil_1.flattenUserClients)(recipients, domain);
     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 });
+            const sessionId = constructSessionId({ userId, clientId, useQualifiedIds: !!domain });
             if (await cryptoClient.sessionExists(sessionId)) {
                 existingSessions.push(sessionId);
                 continue;
             }
-            if (!Array.isArray(data)) {
-                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;
-            }
-            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;
+            missingUserClients[userId.id] = missingUserClients[userId.id] || [];
+            missingUserClients[userId.id].push(clientId);
         }
     }
-    const { sessions: prekeyCreated, unknowns: prekeyUnknows } = Object.keys(missingClientsWithPrekeys).length > 0
-        ? await createSessionsFromPreKeys({
-            recipients: missingClientsWithPrekeys,
-            cryptoClient,
-        })
-        : { sessions: [], unknowns: {} };
-    const { sessions: created, failed, unknowns, } = Object.keys(missingClients).length > 0
-        ? await createSessions({
-            recipients: missingClients,
-            apiClient,
-            cryptoClient,
-            logger,
-        })
-        : { sessions: [], failed: undefined, unknowns: undefined };
-    const allUnknowns = Object.assign(Object.assign({}, prekeyUnknows), unknowns);
-    return {
-        sessions: [...existingSessions, ...prekeyCreated, ...created],
-        failed,
-        unknowns: Object.keys(allUnknowns).length > 0 ? allUnknowns : undefined,
-    };
+    if (Object.keys(missingUserClients).length === 0) {
+        return existingSessions;
+    }
+    const newSessions = await createSessions({
+        userClientMap: missingUserClients,
+        domain,
+        apiClient,
+        cryptoClient,
+        logger,
+    });
+    return [...existingSessions, ...newSessions];
 };
 exports.initSessions = initSessions;
 async function deleteSession(params) {
@@ -128,46 +152,34 @@ async function deleteSession(params) {
     await params.cryptoClient.deleteSession(sessionId);
 }
 exports.deleteSession = deleteSession;
-const createSessionsFromPreKeys = async ({ recipients, cryptoClient, }) => {
-    var _a, _b;
+const createSessionsFromPreKeys = async ({ preKeyBundleMap, domain = '', useQualifiedIds, cryptoClient, logger, }) => {
     const sessions = [];
-    const unknowns = {};
-    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);
+    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) {
+                logger === null || logger === void 0 ? void 0 : logger.warn(`A prekey for client ${clientId} of user ${userId}${domain ? ` on domain ${domain}` : ''} was not found, session won't be created.`);
+                continue;
             }
+            const prekeyBuffer = bazinga64_1.Decoder.fromBase64(prekey.key).asBytes;
+            await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
+            await cryptoClient.saveSession(sessionId);
+            sessions.push(sessionId);
         }
     }
-    return { sessions, unknowns };
+    return sessions;
 };
 /**
  * creates an encrypted payload that can be sent to backend from a bunch of sessionIds/encrypted payload
  */
 const buildEncryptedPayloads = (payloads) => {
     return [...payloads].reduce((acc, [sessionId, 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;
+        var _a;
+        const { userId, clientId } = parseSessionId(sessionId);
+        acc[userId] = (_a = acc[userId]) !== null && _a !== void 0 ? _a : {};
+        acc[userId][clientId] = payload;
         return acc;
     }, {});
 };

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

@@ -20,29 +20,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const api_client_1 = require("@wireapp/api-client");
 const SessionHandler_1 = require("./SessionHandler");
-function generatePrekeys(recipients) {
-    const prekeys = {};
-    const failed = [];
-    Object.entries(recipients).forEach(([domain, userClients]) => {
-        Object.entries(userClients).forEach(([userId, clientIds]) => {
-            if (domain.startsWith('offline:')) {
-                failed.push({ id: userId, domain });
-                return;
-            }
-            const domainUsers = prekeys[domain] || {};
-            domainUsers[userId] = clientIds.reduce((acc, clientId, index) => {
-                const payload = clientId.startsWith('deleted:')
-                    ? null
-                    : {
-                        id: index,
-                        key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-                    };
-                return Object.assign(Object.assign({}, acc), { [clientId]: payload });
-            }, {});
-            prekeys[domain] = domainUsers;
-        });
-    });
-    return Promise.resolve({ qualified_user_client_prekeys: prekeys, failed_to_list: failed });
+function generatePrekeys(userId, clientIds) {
+    const clients = clientIds.reduce((prekeys, clientId, index) => {
+        return Object.assign(Object.assign({}, prekeys), { [clientId]: {
+                id: index,
+                key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
+            } });
+    }, {});
+    return {
+        [userId.id]: Object.assign({}, clients),
+    };
 }
 describe('SessionHandler', () => {
     const cryptoClient = {
@@ -53,19 +40,27 @@ describe('SessionHandler', () => {
         deleteSession: jest.fn(),
     };
     const apiClient = new api_client_1.APIClient({ urls: api_client_1.APIClient.BACKEND.STAGING });
-    beforeAll(() => {
-        jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockImplementation(generatePrekeys);
-    });
     describe('constructSessionId', () => {
         describe('constructs a session ID', () => {
             it('without a domain', () => {
-                const sessionId = (0, SessionHandler_1.constructSessionId)({ userId: { id: 'user-id', domain: '' }, clientId: 'client-id' });
+                const sessionId = (0, SessionHandler_1.constructSessionId)({ userId: 'user-id', clientId: 'client-id', useQualifiedIds: true });
                 expect(sessionId).toBe('user-id@client-id');
             });
             it('with a domain', () => {
                 const sessionId = (0, SessionHandler_1.constructSessionId)({
-                    userId: { id: 'user-id', domain: 'domain' },
+                    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');
             });
@@ -73,6 +68,15 @@ describe('SessionHandler', () => {
                 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', () => {
+                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');
             });
@@ -88,9 +92,27 @@ describe('SessionHandler', () => {
             const userId = { id: 'user1', domain: 'domain' };
             const clientId = 'client1';
             jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
+            jest
+                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
+                .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));
+        });
+        it('indicates the consumer if a session could not be created', async () => {
+            const userId = { id: 'user1', domain: 'domain' };
+            const clientId = 'client1';
+            jest
+                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
+                .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));
@@ -106,57 +128,19 @@ 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(cryptoClient, 'sessionExists')
                 .mockImplementation(sessionId => Promise.resolve(sessionId.includes('missing')));
             const sessionFromPrekeySpy = jest.spyOn(cryptoClient, 'sessionFromPrekey');
-            const { sessions } = await (0, SessionHandler_1.initSessions)({
-                recipients: { domain: Object.assign(Object.assign({}, existingUserClients), missingUserClients) },
+            const sessions = await (0, SessionHandler_1.initSessions)({
+                recipients: Object.assign(Object.assign({}, existingUserClients), missingUserClients),
                 apiClient,
                 cryptoClient,
             });
             expect(sessionFromPrekeySpy).toHaveBeenCalledTimes(3);
             expect(sessions).toHaveLength(6);
         });
-        it('returns the list of deleted clients (clients with null prekeys)', async () => {
-            const userClients = {
-                'existing-user1': ['client1', 'deleted:client2'],
-            };
-            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': ['deleted:client2'] } });
-        });
-        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(['domain1@existing-user1@client11', 'domain2@existing-user2@client21']);
-            expect(unknowns).toBeUndefined();
-        });
-        it('returns failed session creation', async () => {
-            const recipients = {
-                domain1: { 'existing-user1': ['client1'] },
-                'offline:domain': { user2: ['client12'] },
-            };
-            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
-            const { sessions, failed } = await (0, SessionHandler_1.initSessions)({
-                recipients,
-                apiClient,
-                cryptoClient,
-            });
-            expect(sessions).toEqual(['domain1@existing-user1@client1']);
-            expect(failed).toEqual([{ id: 'user2', domain: 'offline:domain' }]);
-        });
     });
 });

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

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