@wireapp/core 38.15.2 → 39.0.1

package/lib/conversation/message/MessageService.js

@@ -24,64 +24,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageService = void 0;
 const StringUtil_1 = require("@wireapp/commons/lib/util/StringUtil");
 const otr_1 = require("@wireapp/protocol-messaging/web/otr");
-const bazinga64_1 = require("bazinga64");
 const http_status_codes_1 = require("http-status-codes");
 const long_1 = __importDefault(require("long"));
-const protocol_messaging_1 = require("@wireapp/protocol-messaging");
-const MessageBuilder_1 = require("./MessageBuilder");
-const RecipientsHelper_1 = require("./RecipientsHelper");
 const UserClientsUtil_1 = require("./UserClientsUtil");
-const __1 = require("..");
-const AssetCryptography_1 = require("../../cryptography/AssetCryptography");
 const util_1 = require("../../util");
 class MessageService {
     constructor(apiClient, proteusService) {
         this.apiClient = apiClient;
         this.proteusService = proteusService;
     }
-    /**
-     * Sends a message to a non-federated backend.
-     *
-     * @param sendingClientId The clientId of the current user
-     * @param recipients The list of recipients to send the message to
-     * @param plainText The plainText data to send
-     * @param options.conversationId? the conversation to send the message to. Will broadcast if not set
-     * @param options.reportMissing? trigger a mismatch error when there are missing recipients in the payload
-     * @param options.sendAsProtobuf?
-     * @param options.onClientMismatch? Called when a mismatch happens on the server
-     * @return the ClientMismatch status returned by the backend
-     */
-    async sendMessage(sendingClientId, recipients, plainText, options = {}) {
-        let plainTextPayload = plainText;
-        let cipherText;
-        if (this.shouldSendAsExternal(plainText, recipients)) {
-            const externalPayload = await this.generateExternalPayload(plainText);
-            plainTextPayload = externalPayload.text;
-            cipherText = externalPayload.cipherText;
-        }
-        const { payloads: encryptedPayload, unknowns } = await this.proteusService.encrypt(plainTextPayload, recipients);
-        const send = async (payload) => {
-            const result = options.sendAsProtobuf
-                ? await this.sendOTRProtobufMessage(sendingClientId, payload, Object.assign(Object.assign({}, options), { assetData: cipherText }))
-                : await this.sendOTRMessage(sendingClientId, payload, Object.assign(Object.assign({}, options), { assetData: cipherText }));
-            return unknowns ? Object.assign(Object.assign({}, result), { deleted: Object.assign(Object.assign({}, result.deleted), unknowns) }) : result;
-        };
-        try {
-            return await send(encryptedPayload);
-        }
-        catch (error) {
-            if (!this.isClientMismatchError(error)) {
-                throw error;
-            }
-            const mismatch = error.response.data;
-            const shouldStopSending = options.onClientMismatch && (await options.onClientMismatch(mismatch)) === false;
-            if (shouldStopSending) {
-                return Object.assign(Object.assign({}, mismatch), { canceled: true });
-            }
-            const reEncryptedMessage = await this.reencryptAfterMismatch(mismatch, encryptedPayload, plainText);
-            return send(reEncryptedMessage);
-        }
-    }
     /**
      * Sends a message to a federated backend.
      *
@@ -94,10 +45,10 @@ class MessageService {
      * @param options.onClientMismatch? Called when a mismatch happens on the server
      * @return the MessageSendingStatus returned by the backend
      */
-    async sendFederatedMessage(sendingClientId, recipients, plainText, options) {
-        const { payloads: encryptedPayload, unknowns: unknows } = await this.proteusService.encryptQualified(plainText, recipients);
+    async sendMessage(sendingClientId, recipients, plainText, options = {}) {
+        const { payloads: encryptedPayload, unknowns: unknows } = await this.proteusService.encrypt(plainText, recipients);
         const send = async (payload) => {
-            const result = await this.sendFederatedOtrMessage(sendingClientId, payload, options);
+            const result = await this.sendOtrMessage(sendingClientId, payload, options);
             return unknows ? Object.assign(Object.assign({}, result), { deleted: Object.assign(Object.assign({}, result.deleted), unknows) }) : result;
         };
         try {
@@ -112,11 +63,11 @@ class MessageService {
             if (shouldStopSending) {
                 return Object.assign(Object.assign({}, mismatch), { canceled: true });
             }
-            const reEncryptedPayload = await this.reencryptAfterFederatedMismatch(mismatch, encryptedPayload, plainText);
+            const reEncryptedPayload = await this.reencryptAfterMismatch(mismatch, encryptedPayload, plainText);
             return send(reEncryptedPayload);
         }
     }
-    async sendFederatedOtrMessage(sendingClientId, recipients, options) {
+    async sendOtrMessage(sendingClientId, recipients, options) {
         const qualifiedUserEntries = Object.entries(recipients).map(([domain, otrRecipients]) => {
             const userEntries = Object.entries(otrRecipients).map(([userId, otrClientMap]) => {
                 const clientEntries = Object.entries(otrClientMap).map(([clientId, payload]) => {
@@ -158,69 +109,15 @@ class MessageService {
             protoMessage.ignoreAll = true;
         }
         if (!options.conversationId) {
-            return this.apiClient.api.broadcast.postBroadcastFederatedMessage(sendingClientId, protoMessage);
+            return this.apiClient.api.broadcast.postBroadcastMessage(sendingClientId, protoMessage);
         }
         const { id, domain } = options.conversationId;
-        return this.apiClient.api.conversation.postOTRMessageV2(id, domain, protoMessage);
-    }
-    async sendOTRMessage(sendingClientId, recipients, options) {
-        const message = {
-            data: options.assetData ? bazinga64_1.Encoder.toBase64(options.assetData).asString : undefined,
-            recipients: (0, RecipientsHelper_1.recipientsToBase64)(recipients),
-            sender: sendingClientId,
-            native_push: options.nativePush,
-        };
-        let ignoreMissing;
-        if ((0, util_1.isStringArray)(options.reportMissing)) {
-            message.report_missing = options.reportMissing;
-        }
-        else {
-            // By default we want ignore missing to be false (and have mismatch errors in case some clients are missing)
-            ignoreMissing = typeof options.reportMissing === 'boolean' ? !options.reportMissing : false;
-        }
-        return !options.conversationId
-            ? this.apiClient.api.broadcast.postBroadcastMessage(sendingClientId, message, ignoreMissing)
-            : this.apiClient.api.conversation.postOTRMessage(sendingClientId, options.conversationId.id, message, ignoreMissing);
-    }
-    async generateExternalPayload(plainText) {
-        const asset = await (0, AssetCryptography_1.encryptAsset)({ plainText });
-        const { cipherText, keyBytes, sha256 } = asset;
-        const externalMessage = {
-            otrKey: new Uint8Array(keyBytes),
-            sha256: new Uint8Array(sha256),
-        };
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [__1.GenericMessageType.EXTERNAL]: externalMessage,
-            messageId: (0, MessageBuilder_1.createId)(),
-        });
-        return { text: protocol_messaging_1.GenericMessage.encode(genericMessage).finish(), cipherText };
-    }
-    shouldSendAsExternal(plainText, preKeyBundles) {
-        const EXTERNAL_MESSAGE_THRESHOLD_BYTES = 200 * 1024;
-        let clientCount = 0;
-        for (const user in preKeyBundles) {
-            clientCount += Object.keys(preKeyBundles[user]).length;
-        }
-        const messageInBytes = new Uint8Array(plainText).length;
-        const estimatedPayloadInBytes = clientCount * messageInBytes;
-        return estimatedPayloadInBytes > EXTERNAL_MESSAGE_THRESHOLD_BYTES;
+        return this.apiClient.api.conversation.postOTRMessage(id, domain, protoMessage);
     }
     isClientMismatchError(error) {
         var _a;
         return ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === http_status_codes_1.StatusCodes.PRECONDITION_FAILED;
     }
-    async reencryptAfterMismatch(mismatch, recipients, plainText) {
-        const deleted = (0, UserClientsUtil_1.flattenUserClients)(mismatch.deleted);
-        // remove deleted clients to the recipients
-        deleted.forEach(({ userId, data }) => data.forEach(clientId => delete recipients[userId.id][clientId]));
-        if (Object.keys(mismatch.missing).length) {
-            const { payloads } = await this.proteusService.encrypt(plainText, mismatch.missing);
-            const reEncryptedPayloads = (0, UserClientsUtil_1.flattenUserClients)(payloads);
-            // add missing clients to the recipients
-            reEncryptedPayloads.forEach(({ data, userId }) => (recipients[userId.id] = Object.assign(Object.assign({}, recipients[userId.id]), data)));
-        }
-        return recipients;
-    }
     /**
      * Will re-encrypt a message when there were some missing clients in the initial send (typically when the server replies with a client mismatch error)
      *
@@ -229,55 +126,16 @@ class MessageService {
      * @param {Uint8Array} plainText The text that should be encrypted for the missing clients
      * @return resolves with a new message payload that can be sent
      */
-    async reencryptAfterFederatedMismatch(mismatch, recipients, plainText) {
+    async reencryptAfterMismatch(mismatch, recipients, plainText) {
         const deleted = (0, UserClientsUtil_1.flattenQualifiedUserClients)(mismatch.deleted);
         // remove deleted clients to the recipients
         deleted.forEach(({ userId, data }) => data.forEach(clientId => delete recipients[userId.domain][userId.id][clientId]));
         if (Object.keys(mismatch.missing).length) {
-            const { payloads } = await this.proteusService.encryptQualified(plainText, mismatch.missing);
+            const { payloads } = await this.proteusService.encrypt(plainText, mismatch.missing);
             const reEncryptedPayloads = (0, UserClientsUtil_1.flattenQualifiedUserClients)(payloads);
             reEncryptedPayloads.forEach(({ data, userId }) => (recipients[userId.domain][userId.id] = Object.assign(Object.assign({}, recipients[userId.domain][userId.id]), data)));
         }
         return recipients;
     }
-    async sendOTRProtobufMessage(sendingClientId, recipients, options) {
-        const userEntries = Object.entries(recipients).map(([userId, otrClientMap]) => {
-            const clients = Object.entries(otrClientMap).map(([clientId, payload]) => {
-                return {
-                    client: {
-                        client: long_1.default.fromString(clientId, 16),
-                    },
-                    text: payload,
-                };
-            });
-            return {
-                clients,
-                user: {
-                    uuid: (0, StringUtil_1.uuidToBytes)(userId),
-                },
-            };
-        });
-        const protoMessage = otr_1.proteus.NewOtrMessage.create({
-            recipients: userEntries,
-            sender: {
-                client: long_1.default.fromString(sendingClientId, 16),
-            },
-        });
-        let ignoreMissing;
-        if ((0, util_1.isStringArray)(options.reportMissing)) {
-            const encoder = new TextEncoder();
-            protoMessage.reportMissing = options.reportMissing.map(userId => ({ uuid: encoder.encode(userId) }));
-        }
-        else {
-            // By default we want ignore missing to be false (and have mismatch errors in case some clients are missing)
-            ignoreMissing = typeof options.reportMissing === 'boolean' ? !options.reportMissing : false;
-        }
-        if (options.assetData) {
-            protoMessage.blob = options.assetData;
-        }
-        return !options.conversationId
-            ? this.apiClient.api.broadcast.postBroadcastProtobufMessage(sendingClientId, protoMessage, ignoreMissing)
-            : this.apiClient.api.conversation.postOTRProtobufMessage(sendingClientId, options.conversationId.id, protoMessage, ignoreMissing);
-    }
 }
 exports.MessageService = MessageService;

package/lib/conversation/message/MessageService.test.js

@@ -51,12 +51,14 @@ function generateQualifiedRecipients(users) {
     return payload;
 }
 function generateRecipients(users) {
-    return users.reduce((acc, { id, clients }) => {
-        acc[id] = clients;
+    return users.reduce((acc, { id, domain, clients }) => {
+        const domainUsers = acc[domain] || {};
+        domainUsers[id] = clients;
+        acc[domain] = domainUsers;
         return acc;
     }, {});
 }
-function fakeEncryptQualified(_, recipients) {
+function fakeEncrypt(_, recipients) {
     const encryptedPayload = Object.entries(recipients).reduce((acc, [domain, users]) => {
         acc[domain] = Object.entries(users).reduce((userClients, [userId, clients]) => {
             userClients[userId] = clients.reduce((payloads, client) => {
@@ -69,42 +71,74 @@ function fakeEncryptQualified(_, recipients) {
     }, {});
     return Promise.resolve({ payloads: encryptedPayload });
 }
-function fakeEncrypt(_, recipients) {
-    const encryptedPayload = Object.entries(recipients).reduce((userClients, [userId, clients]) => {
-        userClients[userId] || (userClients[userId] = clients.reduce((acc, clientId) => {
-            acc[clientId] = new Uint8Array();
-            return acc;
-        }, {}));
-        return userClients;
-    }, {});
-    return Promise.resolve({ payloads: encryptedPayload });
-}
 const buildMessageService = async () => {
     const apiClient = new api_client_1.APIClient();
-    const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)(true);
+    const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)();
     const messageService = new MessageService_1.MessageService(apiClient, proteusService);
-    jest.spyOn(proteusService, 'encryptQualified').mockImplementation(fakeEncryptQualified);
     jest.spyOn(proteusService, 'encrypt').mockImplementation(fakeEncrypt);
     return [messageService, { apiClient, proteusService }];
 };
 describe('MessageService', () => {
-    describe('sendFederatedMessage', () => {
+    describe('sendMessage', () => {
+        const generateUsers = (userCount, clientsPerUser) => {
+            return Array.from(Array(userCount)).map((_, i) => ({
+                id: `user${i}`,
+                domain: `${i}.domain`,
+                clients: Array.from(Array(clientsPerUser)).map((_, j) => `client${i}${j}`),
+            }));
+        };
+        const clientId = 'sendingClient';
+        const conversationId = { id: 'conv1', domain: '' };
+        const createMessage = (content) => {
+            const customTextMessage = protocol_messaging_1.GenericMessage.create({
+                messageId: (0, PayloadHelper_1.getUUID)(),
+                text: protocol_messaging_1.Text.create({ content }),
+            });
+            return protocol_messaging_1.GenericMessage.encode(customTextMessage).finish();
+        };
         it('sends a message and forwards backend response', async () => {
             const [messageService, { apiClient }] = await buildMessageService();
-            jest.spyOn(apiClient.api.conversation, 'postOTRMessageV2').mockResolvedValue(baseMessageSendingStatus);
+            jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockResolvedValue(baseMessageSendingStatus);
             const recipients = generateQualifiedRecipients([user1, user2]);
-            const result = await messageService.sendFederatedMessage('senderclientid', recipients, new Uint8Array(), {
-                conversationId: { id: 'convid', domain: '' },
+            const result = await messageService.sendMessage('senderclientid', recipients, new Uint8Array(), {
+                conversationId: { id: 'convid', domain: 'domain' },
             });
-            expect(apiClient.api.conversation.postOTRMessageV2).toHaveBeenCalled();
+            expect(apiClient.api.conversation.postOTRMessage).toHaveBeenCalled();
             expect(result).toEqual(baseMessageSendingStatus);
         });
+        it('should send regular to conversation', async () => {
+            const [messageService, { apiClient }] = await buildMessageService();
+            const message = 'Lorem ipsum dolor sit amet';
+            jest
+                .spyOn(apiClient.api.conversation, 'postOTRMessage')
+                .mockReturnValue(Promise.resolve({}));
+            await messageService.sendMessage(clientId, generateRecipients(generateUsers(3, 3)), createMessage(message), {
+                conversationId,
+            });
+            expect(apiClient.api.conversation.postOTRMessage).toHaveBeenCalledWith(conversationId.id, conversationId.domain, expect.any(Object));
+        });
+        it('should broadcast regular message if no conversationId is given', async () => {
+            const [messageService, { apiClient }] = await buildMessageService();
+            const message = 'Lorem ipsum dolor sit amet';
+            jest
+                .spyOn(apiClient.api.broadcast, 'postBroadcastMessage')
+                .mockReturnValue(Promise.resolve({}));
+            await messageService.sendMessage(clientId, generateRecipients(generateUsers(3, 3)), createMessage(message));
+            expect(apiClient.api.broadcast.postBroadcastMessage).toHaveBeenCalledWith(clientId, expect.any(Object));
+        });
         describe('client mismatch', () => {
+            const baseClientMismatch = {
+                deleted: {},
+                missing: {},
+                redundant: {},
+                failed_to_send: {},
+                time: new Date().toISOString(),
+            };
             it('handles client mismatch internally if no onClientMismatch is given', async () => {
                 const [messageService, { apiClient }] = await buildMessageService();
                 let spyCounter = 0;
-                const clientMismatch = Object.assign(Object.assign({}, baseMessageSendingStatus), { deleted: { [user1.domain]: { [user1.id]: [user1.clients[0]] } }, missing: { '2.wire.test': { [user2.id]: ['client22'] } } });
-                jest.spyOn(apiClient.api.conversation, 'postOTRMessageV2').mockImplementation(() => {
+                const clientMismatch = Object.assign(Object.assign({}, baseClientMismatch), { deleted: { [user1.domain]: { [user1.id]: [user1.clients[0]] } }, missing: { [user2.domain]: { [user2.id]: ['client22'] } } });
+                jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockImplementation(() => {
                     spyCounter++;
                     if (spyCounter === 1) {
                         const error = new Error();
@@ -114,22 +148,22 @@ describe('MessageService', () => {
                         };
                         return Promise.reject(error);
                     }
-                    return Promise.resolve(baseMessageSendingStatus);
+                    return Promise.resolve(baseClientMismatch);
                 });
-                jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockReturnValue(Promise.resolve({}));
-                const recipients = generateQualifiedRecipients([user1, user2]);
-                await messageService.sendFederatedMessage('senderclientid', recipients, new Uint8Array(), {
+                jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockReturnValue(Promise.resolve({}));
+                const recipients = generateRecipients([user1, user2]);
+                await messageService.sendMessage('senderclientid', recipients, new Uint8Array(), {
                     reportMissing: true,
                     conversationId: { id: 'convid', domain: '' },
                 });
-                expect(apiClient.api.conversation.postOTRMessageV2).toHaveBeenCalledTimes(2);
+                expect(apiClient.api.conversation.postOTRMessage).toHaveBeenCalledTimes(2);
             });
             it('continues message sending if onClientMismatch returns true', async () => {
                 const [messageService, { apiClient }] = await buildMessageService();
-                const onClientMismatch = jest.fn().mockReturnValue(true);
-                const clientMismatch = Object.assign(Object.assign({}, baseMessageSendingStatus), { missing: { '2.wire.test': { [user2.id]: ['client22'] } } });
+                const onClientMismatch = jest.fn().mockReturnValue(Promise.resolve(true));
+                const clientMismatch = Object.assign(Object.assign({}, baseClientMismatch), { missing: { [user2.domain]: { [user2.id]: ['client22'] } } });
                 let spyCounter = 0;
-                jest.spyOn(apiClient.api.conversation, 'postOTRMessageV2').mockImplementation(() => {
+                jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockImplementation(() => {
                     spyCounter++;
                     if (spyCounter === 1) {
                         const error = new Error();
@@ -139,44 +173,23 @@ describe('MessageService', () => {
                         };
                         return Promise.reject(error);
                     }
-                    return Promise.resolve(baseMessageSendingStatus);
+                    return Promise.resolve(baseClientMismatch);
                 });
-                jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockReturnValue(Promise.resolve({}));
-                const recipients = generateQualifiedRecipients([user1, user2]);
-                await messageService.sendFederatedMessage('senderclientid', recipients, new Uint8Array(), {
+                jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockReturnValue(Promise.resolve({}));
+                const recipients = generateRecipients([user1, user2]);
+                await messageService.sendMessage('senderclientid', recipients, new Uint8Array(), {
                     reportMissing: true,
                     onClientMismatch,
                     conversationId: { id: 'convid', domain: '' },
                 });
-                expect(apiClient.api.conversation.postOTRMessageV2).toHaveBeenCalledTimes(2);
+                expect(apiClient.api.conversation.postOTRMessage).toHaveBeenCalledTimes(2);
                 expect(onClientMismatch).toHaveBeenCalledWith(clientMismatch);
             });
-            it('warns the consumer if they try to send a message to a deleted client', async () => {
-                const [messageService, { apiClient, proteusService }] = await buildMessageService();
-                const onClientMismatch = jest.fn().mockReturnValue(true);
-                const recipients = generateQualifiedRecipients([user1, user2]);
-                const unknowns = {
-                    [user1.domain]: {
-                        [user1.id]: [user1.clients[0]],
-                    },
-                };
-                jest.spyOn(proteusService, 'encryptQualified').mockResolvedValue({
-                    payloads: {},
-                    unknowns,
-                });
-                jest.spyOn(apiClient.api.conversation, 'postOTRMessageV2').mockResolvedValue(baseMessageSendingStatus);
-                const result = await messageService.sendFederatedMessage('senderclientid', recipients, new Uint8Array(), {
-                    reportMissing: true,
-                    onClientMismatch,
-                    conversationId: { id: 'convid', domain: '' },
-                });
-                expect(result.deleted).toEqual(unknowns);
-            });
             it('stops message sending if onClientMismatch returns false', async () => {
                 const [messageService, { apiClient }] = await buildMessageService();
-                const onClientMismatch = jest.fn().mockReturnValue(false);
-                const clientMismatch = Object.assign(Object.assign({}, baseMessageSendingStatus), { missing: { '2.wire.test': { [user2.id]: ['client22'] } } });
-                jest.spyOn(apiClient.api.conversation, 'postOTRMessageV2').mockImplementation(() => {
+                const onClientMismatch = jest.fn().mockReturnValue(Promise.resolve(false));
+                const clientMismatch = Object.assign(Object.assign({}, baseMessageSendingStatus), { missing: { [user2.id]: ['client22'] } });
+                jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockImplementation(() => {
                     const error = new Error();
                     error.response = {
                         status: http_status_codes_1.StatusCodes.PRECONDITION_FAILED,
@@ -184,105 +197,22 @@ describe('MessageService', () => {
                     };
                     return Promise.reject(error);
                 });
-                jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockReturnValue(Promise.resolve({}));
-                const recipients = generateQualifiedRecipients([user1, user2]);
-                await messageService.sendFederatedMessage('senderclientid', recipients, new Uint8Array(), {
+                jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockReturnValue(Promise.resolve({}));
+                const recipients = generateRecipients([user1, user2]);
+                await messageService.sendMessage('senderclientid', recipients, new Uint8Array(), {
                     reportMissing: true,
                     onClientMismatch,
                     conversationId: { id: 'convid', domain: '' },
                 });
-                expect(apiClient.api.conversation.postOTRMessageV2).toHaveBeenCalledTimes(1);
+                expect(apiClient.api.conversation.postOTRMessage).toHaveBeenCalledTimes(1);
                 expect(onClientMismatch).toHaveBeenCalledWith(clientMismatch);
             });
         });
-    });
-    describe('sendMessage', () => {
-        const generateUsers = (userCount, clientsPerUser) => {
-            return Array.from(Array(userCount)).map((_, i) => ({
-                id: `user${i}`,
-                domain: `${i}.domain`,
-                clients: Array.from(Array(clientsPerUser)).map((_, j) => `client${i}${j}`),
-            }));
-        };
-        const clientId = 'sendingClient';
-        const conversationId = { id: 'conv1', domain: '' };
-        const createMessage = (content) => {
-            const customTextMessage = protocol_messaging_1.GenericMessage.create({
-                messageId: (0, PayloadHelper_1.getUUID)(),
-                text: protocol_messaging_1.Text.create({ content }),
-            });
-            return protocol_messaging_1.GenericMessage.encode(customTextMessage).finish();
-        };
-        it('should send regular to conversation', async () => {
-            const [messageService, { apiClient }] = await buildMessageService();
-            const message = 'Lorem ipsum dolor sit amet';
-            jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockReturnValue(Promise.resolve({}));
-            await messageService.sendMessage(clientId, generateRecipients(generateUsers(3, 3)), createMessage(message), {
-                conversationId,
-            });
-            expect(apiClient.api.conversation.postOTRMessage).toHaveBeenCalledWith(clientId, conversationId.id, expect.any(Object), false);
-        });
-        it('should send protobuf message to conversation', async () => {
-            const [messageService, { apiClient }] = await buildMessageService();
-            const message = 'Lorem ipsum dolor sit amet';
-            jest
-                .spyOn(apiClient.api.conversation, 'postOTRProtobufMessage')
-                .mockReturnValue(Promise.resolve({}));
-            await messageService.sendMessage(clientId, generateRecipients(generateUsers(3, 3)), createMessage(message), {
-                conversationId,
-                sendAsProtobuf: true,
-            });
-            expect(apiClient.api.conversation.postOTRProtobufMessage).toHaveBeenCalledWith(clientId, conversationId.id, expect.any(Object), false);
-        });
-        it('should broadcast regular message if no conversationId is given', async () => {
-            const [messageService, { apiClient }] = await buildMessageService();
-            const message = 'Lorem ipsum dolor sit amet';
-            jest
-                .spyOn(apiClient.api.broadcast, 'postBroadcastMessage')
-                .mockReturnValue(Promise.resolve({}));
-            await messageService.sendMessage(clientId, generateRecipients(generateUsers(3, 3)), createMessage(message));
-            expect(apiClient.api.broadcast.postBroadcastMessage).toHaveBeenCalledWith(clientId, expect.any(Object), false);
-        });
-        it('should broadcast protobuf message if no conversationId is given', async () => {
-            const [messageService, { apiClient }] = await buildMessageService();
-            const message = 'Lorem ipsum dolor sit amet';
-            jest
-                .spyOn(apiClient.api.broadcast, 'postBroadcastProtobufMessage')
-                .mockReturnValue(Promise.resolve({}));
-            await messageService.sendMessage(clientId, generateRecipients(generateUsers(3, 3)), createMessage(message), {
-                sendAsProtobuf: true,
-            });
-            expect(apiClient.api.broadcast.postBroadcastProtobufMessage).toHaveBeenCalledWith(clientId, expect.any(Object), false);
-        });
-        it('should not send as external if payload small', async () => {
-            const [messageService, { apiClient }] = await buildMessageService();
-            const message = 'Lorem ipsum dolor sit amet';
-            jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockReturnValue(Promise.resolve({}));
-            await messageService.sendMessage(clientId, generateRecipients(generateUsers(3, 3)), createMessage(message), {
-                conversationId,
-            });
-            expect(apiClient.api.conversation.postOTRMessage).toHaveBeenCalledWith(clientId, conversationId.id, expect.objectContaining({ data: undefined }), false);
-        });
-        it('should send as external if payload is big', async () => {
-            const [messageService, { apiClient }] = await buildMessageService();
-            const longMessage = 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Duis autem Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Duis autem';
-            jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockReturnValue(Promise.resolve({}));
-            await messageService.sendMessage(clientId, generateRecipients(generateUsers(30, 10)), createMessage(longMessage), {
-                conversationId,
-            });
-            expect(apiClient.api.conversation.postOTRMessage).toHaveBeenCalledWith(clientId, conversationId.id, expect.objectContaining({ data: expect.any(String) }), false);
-        });
         describe('client mismatch', () => {
-            const baseClientMismatch = {
-                deleted: {},
-                missing: {},
-                redundant: {},
-                time: new Date().toISOString(),
-            };
             it('handles client mismatch internally if no onClientMismatch is given', async () => {
                 const [messageService, { apiClient }] = await buildMessageService();
                 let spyCounter = 0;
-                const clientMismatch = Object.assign(Object.assign({}, baseClientMismatch), { deleted: { [user1.id]: [user1.clients[0]] }, missing: { [user2.id]: ['client22'] } });
+                const clientMismatch = Object.assign(Object.assign({}, baseMessageSendingStatus), { deleted: { [user1.domain]: { [user1.id]: [user1.clients[0]] } }, missing: { '2.wire.test': { [user2.id]: ['client22'] } } });
                 jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockImplementation(() => {
                     spyCounter++;
                     if (spyCounter === 1) {
@@ -293,10 +223,10 @@ describe('MessageService', () => {
                         };
                         return Promise.reject(error);
                     }
-                    return Promise.resolve(baseClientMismatch);
+                    return Promise.resolve(baseMessageSendingStatus);
                 });
                 jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockReturnValue(Promise.resolve({}));
-                const recipients = generateRecipients([user1, user2]);
+                const recipients = generateQualifiedRecipients([user1, user2]);
                 await messageService.sendMessage('senderclientid', recipients, new Uint8Array(), {
                     reportMissing: true,
                     conversationId: { id: 'convid', domain: '' },
@@ -305,8 +235,8 @@ describe('MessageService', () => {
             });
             it('continues message sending if onClientMismatch returns true', async () => {
                 const [messageService, { apiClient }] = await buildMessageService();
-                const onClientMismatch = jest.fn().mockReturnValue(Promise.resolve(true));
-                const clientMismatch = Object.assign(Object.assign({}, baseClientMismatch), { missing: { [user2.id]: ['client22'] } });
+                const onClientMismatch = jest.fn().mockReturnValue(true);
+                const clientMismatch = Object.assign(Object.assign({}, baseMessageSendingStatus), { missing: { '2.wire.test': { [user2.id]: ['client22'] } } });
                 let spyCounter = 0;
                 jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockImplementation(() => {
                     spyCounter++;
@@ -318,10 +248,10 @@ describe('MessageService', () => {
                         };
                         return Promise.reject(error);
                     }
-                    return Promise.resolve(baseClientMismatch);
+                    return Promise.resolve(baseMessageSendingStatus);
                 });
                 jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockReturnValue(Promise.resolve({}));
-                const recipients = generateRecipients([user1, user2]);
+                const recipients = generateQualifiedRecipients([user1, user2]);
                 await messageService.sendMessage('senderclientid', recipients, new Uint8Array(), {
                     reportMissing: true,
                     onClientMismatch,
@@ -330,10 +260,31 @@ describe('MessageService', () => {
                 expect(apiClient.api.conversation.postOTRMessage).toHaveBeenCalledTimes(2);
                 expect(onClientMismatch).toHaveBeenCalledWith(clientMismatch);
             });
+            it('warns the consumer if they try to send a message to a deleted client', async () => {
+                const [messageService, { apiClient, proteusService }] = await buildMessageService();
+                const onClientMismatch = jest.fn().mockReturnValue(true);
+                const recipients = generateQualifiedRecipients([user1, user2]);
+                const unknowns = {
+                    [user1.domain]: {
+                        [user1.id]: [user1.clients[0]],
+                    },
+                };
+                jest.spyOn(proteusService, 'encrypt').mockResolvedValue({
+                    payloads: {},
+                    unknowns,
+                });
+                jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockResolvedValue(baseMessageSendingStatus);
+                const result = await messageService.sendMessage('senderclientid', recipients, new Uint8Array(), {
+                    reportMissing: true,
+                    onClientMismatch,
+                    conversationId: { id: 'convid', domain: '' },
+                });
+                expect(result.deleted).toEqual(unknowns);
+            });
             it('stops message sending if onClientMismatch returns false', async () => {
                 const [messageService, { apiClient }] = await buildMessageService();
-                const onClientMismatch = jest.fn().mockReturnValue(Promise.resolve(false));
-                const clientMismatch = Object.assign(Object.assign({}, baseMessageSendingStatus), { missing: { [user2.id]: ['client22'] } });
+                const onClientMismatch = jest.fn().mockReturnValue(false);
+                const clientMismatch = Object.assign(Object.assign({}, baseMessageSendingStatus), { missing: { '2.wire.test': { [user2.id]: ['client22'] } } });
                 jest.spyOn(apiClient.api.conversation, 'postOTRMessage').mockImplementation(() => {
                     const error = new Error();
                     error.response = {
@@ -343,7 +294,7 @@ describe('MessageService', () => {
                     return Promise.reject(error);
                 });
                 jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockReturnValue(Promise.resolve({}));
-                const recipients = generateRecipients([user1, user2]);
+                const recipients = generateQualifiedRecipients([user1, user2]);
                 await messageService.sendMessage('senderclientid', recipients, new Uint8Array(), {
                     reportMissing: true,
                     onClientMismatch,