@wireapp/core 17.21.1 → 17.24.0

package/src/main/conversation/message/MessageService.test.node.ts

@@ -20,7 +20,12 @@
 import UUID from 'uuidjs';
 import {StatusCodes} from 'http-status-codes';
 import {APIClient} from '@wireapp/api-client';
-import {MessageSendingStatus, QualifiedOTRRecipients} from '@wireapp/api-client/src/conversation';
+import {
+  MessageSendingStatus,
+  OTRRecipients,
+  QualifiedOTRRecipients,
+  QualifiedUserClients,
+} from '@wireapp/api-client/src/conversation';
 import {CryptographyService} from '../../cryptography';
 import {MessageService} from './MessageService';
 
@@ -36,60 +41,142 @@ type TestUser = {id: string; domain: string; clients: string[]};
 const user1: TestUser = {id: UUID.genV4().toString(), domain: '1.wire.test', clients: ['client1.1', 'client1.2']};
 const user2: TestUser = {id: UUID.genV4().toString(), domain: '2.wire.test', clients: ['client2.1', 'client2.2']};
 
-function generatePayload(users: TestUser[]): QualifiedOTRRecipients {
-  const payload: QualifiedOTRRecipients = {};
+function generateQualifiedRecipients(users: TestUser[]): QualifiedUserClients {
+  const payload: QualifiedUserClients = {};
   users.forEach(({id, domain, clients}) => {
     payload[domain] ||= {};
-    payload[domain][id] = {};
-    clients.forEach(client => (payload[domain][id][client] = new Uint8Array()));
+    payload[domain][id] = clients;
   });
   return payload;
 }
 
+function fakeEncrypt(_: unknown, recipients: QualifiedUserClients): Promise<QualifiedOTRRecipients> {
+  const encryptedPayload = Object.entries(recipients).reduce((acc, [domain, users]) => {
+    acc[domain] = Object.entries(users).reduce((userClients, [userId, clients]) => {
+      userClients[userId] = clients.reduce((payloads, client) => {
+        payloads[client] = new Uint8Array();
+        return payloads;
+      }, {} as any);
+      return userClients;
+    }, {} as OTRRecipients<Uint8Array>);
+    return acc;
+  }, {} as QualifiedOTRRecipients);
+  return Promise.resolve(encryptedPayload);
+}
+
 describe('MessageService', () => {
   const apiClient = new APIClient();
   const cryptographyService = new CryptographyService(apiClient, {} as any);
   const messageService = new MessageService(apiClient, cryptographyService);
+
+  beforeEach(() => {
+    spyOn(cryptographyService, 'encryptQualified').and.callFake(fakeEncrypt);
+  });
+
   describe('sendFederatedMessage', () => {
     it('sends a message', async () => {
       spyOn(apiClient.conversation.api, 'postOTRMessageV2').and.returnValue(Promise.resolve(baseMessageSendingStatus));
-      const recipients: QualifiedOTRRecipients = generatePayload([user1, user2]);
+      const recipients = generateQualifiedRecipients([user1, user2]);
 
-      await messageService.sendFederatedOTRMessage('senderclientid', 'convid', '', recipients, new Uint8Array());
+      await messageService.sendFederatedOTRMessage(
+        'senderclientid',
+        {id: 'convid', domain: ''},
+        recipients,
+        new Uint8Array(),
+      );
       expect(apiClient.conversation.api.postOTRMessageV2).toHaveBeenCalled();
     });
 
-    it('handles mismatch errors internally if reportMissing is true', async () => {
-      let spyCounter = 0;
-      spyOn(apiClient.conversation.api, 'postOTRMessageV2').and.callFake(() => {
-        spyCounter++;
-        if (spyCounter === 1) {
+    describe('client mismatch', () => {
+      it('handles client mismatch internally if no onClientMismatch is given', async () => {
+        let spyCounter = 0;
+        const clientMismatch = {
+          ...baseMessageSendingStatus,
+          deleted: {[user1.domain]: {[user1.id]: [user1.clients[0]]}},
+          missing: {'2.wire.test': {[user2.id]: ['client22']}},
+        };
+        spyOn(apiClient.conversation.api, 'postOTRMessageV2').and.callFake(() => {
+          spyCounter++;
+          if (spyCounter === 1) {
+            const error = new Error();
+            (error as any).response = {
+              status: StatusCodes.PRECONDITION_FAILED,
+              data: clientMismatch,
+            };
+            return Promise.reject(error);
+          }
+          return Promise.resolve(baseMessageSendingStatus);
+        });
+        spyOn(apiClient.user.api, 'postQualifiedMultiPreKeyBundles').and.returnValue(Promise.resolve({}));
+
+        const recipients = generateQualifiedRecipients([user1, user2]);
+
+        await messageService.sendFederatedOTRMessage(
+          'senderclientid',
+          {id: 'convid', domain: ''},
+          recipients,
+          new Uint8Array(),
+          {reportMissing: true},
+        );
+        expect(apiClient.conversation.api.postOTRMessageV2).toHaveBeenCalledTimes(2);
+      });
+
+      it('continues message sending if onClientMismatch returns true', async () => {
+        const onClientMismatch = jasmine.createSpy().and.returnValue(Promise.resolve(true));
+        const clientMismatch = {...baseMessageSendingStatus, missing: {'2.wire.test': {[user2.id]: ['client22']}}};
+        let spyCounter = 0;
+        spyOn(apiClient.conversation.api, 'postOTRMessageV2').and.callFake(() => {
+          spyCounter++;
+          if (spyCounter === 1) {
+            const error = new Error();
+            (error as any).response = {
+              status: StatusCodes.PRECONDITION_FAILED,
+              data: clientMismatch,
+            };
+            return Promise.reject(error);
+          }
+          return Promise.resolve(baseMessageSendingStatus);
+        });
+        spyOn(apiClient.user.api, 'postQualifiedMultiPreKeyBundles').and.returnValue(Promise.resolve({}));
+
+        const recipients = generateQualifiedRecipients([user1, user2]);
+
+        await messageService.sendFederatedOTRMessage(
+          'senderclientid',
+          {id: 'convid', domain: ''},
+          recipients,
+          new Uint8Array(),
+          {reportMissing: true, onClientMismatch},
+        );
+        expect(apiClient.conversation.api.postOTRMessageV2).toHaveBeenCalledTimes(2);
+        expect(onClientMismatch).toHaveBeenCalledWith(clientMismatch);
+      });
+
+      it('stops message sending if onClientMismatch returns false', async () => {
+        const onClientMismatch = jasmine.createSpy().and.returnValue(Promise.resolve(false));
+        const clientMismatch = {...baseMessageSendingStatus, missing: {'2.wire.test': {[user2.id]: ['client22']}}};
+        spyOn(apiClient.conversation.api, 'postOTRMessageV2').and.callFake(() => {
           const error = new Error();
           (error as any).response = {
             status: StatusCodes.PRECONDITION_FAILED,
-            data: {...baseMessageSendingStatus, missing: {'2.wire.test': {[user2.id]: ['client22']}}},
+            data: clientMismatch,
           };
           return Promise.reject(error);
-        }
-        return Promise.resolve(baseMessageSendingStatus);
-      });
-      spyOn(apiClient.user.api, 'postQualifiedMultiPreKeyBundles').and.returnValue(Promise.resolve({}));
-      spyOn(cryptographyService, 'encryptQualified').and.returnValue(
-        Promise.resolve({'2.wire.test': {[user2.id]: {client22: new Uint8Array()}}}),
-      );
+        });
+        spyOn(apiClient.user.api, 'postQualifiedMultiPreKeyBundles').and.returnValue(Promise.resolve({}));
 
-      const recipients: QualifiedOTRRecipients = generatePayload([user1, user2]);
+        const recipients = generateQualifiedRecipients([user1, user2]);
 
-      await messageService.sendFederatedOTRMessage(
-        'senderclientid',
-        'convid',
-        '',
-        recipients,
-        new Uint8Array(),
-        undefined,
-        true,
-      );
-      expect(apiClient.conversation.api.postOTRMessageV2).toHaveBeenCalledTimes(2);
+        await messageService.sendFederatedOTRMessage(
+          'senderclientid',
+          {id: 'convid', domain: ''},
+          recipients,
+          new Uint8Array(),
+          {reportMissing: true, onClientMismatch},
+        );
+        expect(apiClient.conversation.api.postOTRMessageV2).toHaveBeenCalledTimes(1);
+        expect(onClientMismatch).toHaveBeenCalledWith(clientMismatch);
+      });
     });
   });
 });

package/src/main/conversation/message/MessageService.ts

@@ -35,11 +35,9 @@ import {
 import {Decoder, Encoder} from 'bazinga64';
 
 import {CryptographyService} from '../../cryptography';
+import {QualifiedId, QualifiedUserPreKeyBundleMap} from '@wireapp/api-client/src/user';
 
-type ClientMismatchError = AxiosError<{
-  deleted: UserClients;
-  missing: UserClients;
-}>;
+type ClientMismatchError = AxiosError<ClientMismatch>;
 
 export class MessageService {
   constructor(private readonly apiClient: APIClient, private readonly cryptographyService: CryptographyService) {}
@@ -75,8 +73,11 @@ export class MessageService {
         ignoreMissing,
       );
     } catch (error) {
+      if (!this.isClientMismatchError(error)) {
+        throw error;
+      }
       const reEncryptedMessage = await this.onClientMismatch(
-        error as AxiosError,
+        error.response!.data,
         {...message, data: base64CipherText ? Decoder.fromBase64(base64CipherText).asBytes : undefined, recipients},
         plainTextArray,
       );
@@ -104,14 +105,18 @@ export class MessageService {
       'redundant',
     ];
 
-    if (messageData.ignoreOnly?.userIds?.length) {
-      const allFailed: QualifiedUserClients = {
-        ...messageSendingStatus.deleted,
-        ...messageSendingStatus.failed_to_send,
-        ...messageSendingStatus.missing,
-        ...messageSendingStatus.redundant,
-      };
+    const allFailed: QualifiedUserClients = {
+      ...messageSendingStatus.deleted,
+      ...messageSendingStatus.failed_to_send,
+      ...messageSendingStatus.missing,
+      ...messageSendingStatus.redundant,
+    };
+    const hasDiffs = Object.keys(allFailed).length;
+    if (!hasDiffs) {
+      return null;
+    }
 
+    if (messageData.ignoreOnly?.userIds?.length) {
       for (const [domainFailed, userClientsFailed] of Object.entries(allFailed)) {
         for (const userIdMissing of Object.keys(userClientsFailed)) {
           const userIsIgnored = messageData.ignoreOnly.userIds.find(({domain: domainIgnore, id: userIdIgnore}) => {
@@ -148,14 +153,18 @@ export class MessageService {
 
   public async sendFederatedOTRMessage(
     sendingClientId: string,
-    conversationId: string,
-    conversationDomain: string,
-    recipients: QualifiedOTRRecipients,
+    {id: conversationId, domain}: QualifiedId,
+    recipients: QualifiedUserClients | QualifiedUserPreKeyBundleMap,
     plainTextArray: Uint8Array,
-    assetData?: Uint8Array,
-    reportMissing?: boolean,
+    options: {
+      assetData?: Uint8Array;
+      reportMissing?: boolean;
+      onClientMismatch?: (mismatch: MessageSendingStatus) => Promise<boolean | undefined>;
+    } = {},
   ): Promise<MessageSendingStatus> {
-    const qualifiedUserEntries = Object.entries(recipients).map<ProtobufOTR.IQualifiedUserEntry>(
+    const otrRecipients = await this.cryptographyService.encryptQualified(plainTextArray, recipients);
+
+    const qualifiedUserEntries = Object.entries(otrRecipients).map<ProtobufOTR.IQualifiedUserEntry>(
       ([domain, otrRecipients]) => {
         const userEntries = Object.entries(otrRecipients).map<ProtobufOTR.IUserEntry>(([userId, otrClientMap]) => {
           const clientEntries = Object.entries(otrClientMap).map<ProtobufOTR.IClientEntry>(([clientId, payload]) => {
@@ -186,8 +195,8 @@ export class MessageService {
       },
     });
 
-    if (assetData) {
-      protoMessage.blob = assetData;
+    if (options.assetData) {
+      protoMessage.blob = options.assetData;
     }
 
     /*
@@ -195,31 +204,33 @@ export class MessageService {
      * missing clients. We have to ignore missing clients because there can be the case that there are clients that
      * don't provide PreKeys (clients from the Pre-E2EE era).
      */
-    if (reportMissing) {
+    if (options.reportMissing) {
       protoMessage.reportAll = {};
     } else {
       protoMessage.ignoreAll = {};
     }
 
     let sendingStatus: MessageSendingStatus;
+    let sendingFailed: boolean = false;
     try {
-      sendingStatus = await this.apiClient.conversation.api.postOTRMessageV2(
-        conversationId,
-        conversationDomain,
-        protoMessage,
-      );
+      sendingStatus = await this.apiClient.conversation.api.postOTRMessageV2(conversationId, domain, protoMessage);
     } catch (error) {
       if (!this.isClientMismatchError(error)) {
         throw error;
       }
       sendingStatus = error.response!.data! as unknown as MessageSendingStatus;
+      sendingFailed = true;
     }
 
     const mismatch = this.checkFederatedClientsMismatch(protoMessage, sendingStatus);
 
     if (mismatch) {
-      const reEncryptedMessage = await this.encryptForMissingClients(protoMessage, mismatch, plainTextArray);
-      await this.apiClient.conversation.api.postOTRMessageV2(conversationId, conversationDomain, reEncryptedMessage);
+      const shouldStopSending = options.onClientMismatch && !(await options.onClientMismatch(mismatch));
+      if (shouldStopSending || !sendingFailed) {
+        return sendingStatus;
+      }
+      const reEncryptedMessage = await this.onFederatedMismatch(protoMessage, mismatch, plainTextArray);
+      await this.apiClient.conversation.api.postOTRMessageV2(conversationId, domain, reEncryptedMessage);
     }
     return sendingStatus;
   }
@@ -282,7 +293,11 @@ export class MessageService {
         ignoreMissing,
       );
     } catch (error) {
-      const reEncryptedMessage = await this.onClientProtobufMismatch(error as AxiosError, protoMessage, plainTextArray);
+      if (!this.isClientMismatchError(error)) {
+        throw error;
+      }
+      const mismatch = error.response!.data;
+      const reEncryptedMessage = await this.onClientProtobufMismatch(mismatch, protoMessage, plainTextArray);
       if (conversationId === null) {
         return await this.apiClient.broadcast.api.postBroadcastProtobufMessage(sendingClientId, reEncryptedMessage);
       }
@@ -296,189 +311,188 @@ export class MessageService {
   }
 
   private async onClientMismatch(
-    error: AxiosError,
+    clientMismatch: ClientMismatch,
     message: NewOTRMessage<Uint8Array>,
     plainTextArray: Uint8Array,
   ): Promise<NewOTRMessage<Uint8Array>> {
-    if (error.response?.status === HTTP_STATUS.PRECONDITION_FAILED) {
-      const {missing, deleted} = (error as ClientMismatchError).response?.data!;
-
-      const deletedUserIds = Object.keys(deleted);
-      const missingUserIds = Object.keys(missing);
-
-      if (deletedUserIds.length) {
-        for (const deletedUserId of deletedUserIds) {
-          for (const deletedClientId of deleted[deletedUserId]) {
-            const deletedUser = message.recipients[deletedUserId];
-            if (deletedUser) {
-              delete deletedUser[deletedClientId];
-            }
+    const {missing, deleted} = clientMismatch;
+
+    const deletedUserIds = Object.keys(deleted);
+    const missingUserIds = Object.keys(missing);
+
+    if (deletedUserIds.length) {
+      for (const deletedUserId of deletedUserIds) {
+        for (const deletedClientId of deleted[deletedUserId]) {
+          const deletedUser = message.recipients[deletedUserId];
+          if (deletedUser) {
+            delete deletedUser[deletedClientId];
           }
         }
       }
+    }
 
-      if (missingUserIds.length) {
-        const missingPreKeyBundles = await this.apiClient.user.api.postMultiPreKeyBundles(missing);
-        const reEncryptedPayloads = await this.cryptographyService.encrypt(plainTextArray, missingPreKeyBundles);
-        for (const missingUserId of missingUserIds) {
-          for (const missingClientId in reEncryptedPayloads[missingUserId]) {
-            const missingUser = message.recipients[missingUserId];
-            if (!missingUser) {
-              message.recipients[missingUserId] = {};
-            }
-
-            message.recipients[missingUserId][missingClientId] = reEncryptedPayloads[missingUserId][missingClientId];
+    if (missingUserIds.length) {
+      const missingPreKeyBundles = await this.apiClient.user.api.postMultiPreKeyBundles(missing);
+      const reEncryptedPayloads = await this.cryptographyService.encrypt(plainTextArray, missingPreKeyBundles);
+      for (const missingUserId of missingUserIds) {
+        for (const missingClientId in reEncryptedPayloads[missingUserId]) {
+          const missingUser = message.recipients[missingUserId];
+          if (!missingUser) {
+            message.recipients[missingUserId] = {};
           }
+
+          message.recipients[missingUserId][missingClientId] = reEncryptedPayloads[missingUserId][missingClientId];
         }
       }
-
-      return message;
     }
 
-    throw error;
+    return message;
   }
 
   private async onClientProtobufMismatch(
-    error: AxiosError,
+    clientMismatch: {missing: UserClients; deleted: UserClients},
     message: ProtobufOTR.NewOtrMessage,
     plainTextArray: Uint8Array,
   ): Promise<ProtobufOTR.NewOtrMessage> {
-    if (error.response?.status === HTTP_STATUS.PRECONDITION_FAILED) {
-      const {missing, deleted} = (error as ClientMismatchError).response?.data!;
-
-      const deletedUserIds = Object.keys(deleted);
-      const missingUserIds = Object.keys(missing);
-
-      if (deletedUserIds.length) {
-        for (const deletedUserId of deletedUserIds) {
-          for (const deletedClientId of deleted[deletedUserId]) {
-            const deletedUserIndex = message.recipients.findIndex(({user}) => bytesToUUID(user.uuid) === deletedUserId);
-            if (deletedUserIndex > -1) {
-              const deletedClientIndex = message.recipients[deletedUserIndex].clients?.findIndex(({client}) => {
-                return client.client.toString(16) === deletedClientId;
-              });
-              if (typeof deletedClientIndex !== 'undefined' && deletedClientIndex > -1) {
-                delete message.recipients[deletedUserIndex].clients?.[deletedClientIndex!];
-              }
+    const {missing, deleted} = clientMismatch;
+
+    const deletedUserIds = Object.keys(deleted);
+    const missingUserIds = Object.keys(missing);
+
+    if (deletedUserIds.length) {
+      for (const deletedUserId of deletedUserIds) {
+        for (const deletedClientId of deleted[deletedUserId]) {
+          const deletedUserIndex = message.recipients.findIndex(({user}) => bytesToUUID(user.uuid) === deletedUserId);
+          if (deletedUserIndex > -1) {
+            const deletedClientIndex = message.recipients[deletedUserIndex].clients?.findIndex(({client}) => {
+              return client.client.toString(16) === deletedClientId;
+            });
+            if (typeof deletedClientIndex !== 'undefined' && deletedClientIndex > -1) {
+              delete message.recipients[deletedUserIndex].clients?.[deletedClientIndex!];
             }
           }
         }
       }
+    }
 
-      if (missingUserIds.length) {
-        const missingPreKeyBundles = await this.apiClient.user.api.postMultiPreKeyBundles(missing);
-        const reEncryptedPayloads = await this.cryptographyService.encrypt(plainTextArray, missingPreKeyBundles);
-        for (const missingUserId of missingUserIds) {
-          for (const missingClientId in reEncryptedPayloads[missingUserId]) {
-            const missingUserIndex = message.recipients.findIndex(({user}) => bytesToUUID(user.uuid) === missingUserId);
-            if (missingUserIndex === -1) {
-              message.recipients.push({
-                clients: [
-                  {
-                    client: {
-                      client: Long.fromString(missingClientId, 16),
-                    },
-                    text: reEncryptedPayloads[missingUserId][missingClientId],
+    if (missingUserIds.length) {
+      const missingPreKeyBundles = await this.apiClient.user.api.postMultiPreKeyBundles(missing);
+      const reEncryptedPayloads = await this.cryptographyService.encrypt(plainTextArray, missingPreKeyBundles);
+      for (const missingUserId of missingUserIds) {
+        for (const missingClientId in reEncryptedPayloads[missingUserId]) {
+          const missingUserIndex = message.recipients.findIndex(({user}) => bytesToUUID(user.uuid) === missingUserId);
+          if (missingUserIndex === -1) {
+            message.recipients.push({
+              clients: [
+                {
+                  client: {
+                    client: Long.fromString(missingClientId, 16),
                   },
-                ],
-                user: {
-                  uuid: uuidToBytes(missingUserId),
+                  text: reEncryptedPayloads[missingUserId][missingClientId],
                 },
-              });
-            }
+              ],
+              user: {
+                uuid: uuidToBytes(missingUserId),
+              },
+            });
           }
         }
       }
-
-      return message;
     }
 
-    throw error;
+    return message;
   }
 
-  /**
-   * 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)
-   *
-   * @param {ProtobufOTR.QualifiedNewOtrMessage} messageData The initial message that was sent
-   * @param {MessageSendingStatus} messageSendingStatus Info about the missing/deleted clients
-   * @param {Uint8Array} plainTextArray The text that should be encrypted for the missing clients
-   * @return resolves with a new message payload that can be sent
-   */
-  private async encryptForMissingClients(
-    messageData: ProtobufOTR.QualifiedNewOtrMessage,
-    messageSendingStatus: MessageSendingStatus,
-    plainTextArray: Uint8Array,
-  ): Promise<ProtobufOTR.QualifiedNewOtrMessage> {
+  private deleteExtraQualifiedClients(
+    message: ProtobufOTR.QualifiedNewOtrMessage,
+    deletedClients: MessageSendingStatus['deleted'],
+  ): ProtobufOTR.QualifiedNewOtrMessage {
     // walk through deleted domain/user map
-    for (const [deletedUserDomain, deletedUserIdClients] of Object.entries(messageSendingStatus.deleted)) {
-      if (!messageData.recipients.find(recipient => recipient.domain === deletedUserDomain)) {
+    for (const [deletedUserDomain, deletedUserIdClients] of Object.entries(deletedClients)) {
+      if (!message.recipients.find(recipient => recipient.domain === deletedUserDomain)) {
         // no user from this domain was deleted
         continue;
       }
       // walk through deleted user ids
       for (const [deletedUserId] of Object.entries(deletedUserIdClients)) {
         // walk through message recipients
-        for (const recipientIndex in messageData.recipients) {
+        for (const recipients of message.recipients) {
           // check if message recipients' domain is the same as the deleted user's domain
-          if (messageData.recipients[recipientIndex].domain === deletedUserDomain) {
+          if (recipients.domain === deletedUserDomain) {
             // check if message recipients' id is the same as the deleted user's id
-            for (const entriesIndex in messageData.recipients[recipientIndex].entries || []) {
-              const uuid = messageData.recipients[recipientIndex].entries![entriesIndex].user?.uuid;
+            for (const recipientEntry of recipients.entries || []) {
+              const uuid = recipientEntry.user?.uuid;
               if (!!uuid && bytesToUUID(uuid) === deletedUserId) {
                 // delete this user from the message recipients
-                delete messageData.recipients[recipientIndex].entries![entriesIndex];
+                const deleteIndex = recipients.entries!.indexOf(recipientEntry);
+                recipients.entries!.splice(deleteIndex);
               }
             }
           }
         }
       }
     }
+    return message;
+  }
 
-    const missingUserIds = Object.entries(messageSendingStatus.missing);
-    if (missingUserIds.length) {
-      const missingPreKeyBundles = await this.apiClient.user.api.postQualifiedMultiPreKeyBundles(
-        messageSendingStatus.missing,
-      );
-      const reEncryptedPayloads = await this.cryptographyService.encryptQualified(plainTextArray, missingPreKeyBundles);
+  /**
+   * 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)
+   *
+   * @param {ProtobufOTR.QualifiedNewOtrMessage} messageData The initial message that was sent
+   * @param {MessageSendingStatus} messageSendingStatus Info about the missing/deleted clients
+   * @param {Uint8Array} plainText The text that should be encrypted for the missing clients
+   * @return resolves with a new message payload that can be sent
+   */
+  private async onFederatedMismatch(
+    message: ProtobufOTR.QualifiedNewOtrMessage,
+    {deleted, missing}: MessageSendingStatus,
+    plainText: Uint8Array,
+  ): Promise<ProtobufOTR.QualifiedNewOtrMessage> {
+    message = this.deleteExtraQualifiedClients(message, deleted);
+    if (Object.keys(missing).length) {
+      const missingPreKeyBundles = await this.apiClient.user.api.postQualifiedMultiPreKeyBundles(missing);
+      const reEncryptedPayloads = await this.cryptographyService.encryptQualified(plainText, missingPreKeyBundles);
+      message = this.addMissingQualifiedClients(message, reEncryptedPayloads);
+    }
+    return message;
+  }
 
-      // walk through missing domain/user map
-      for (const [missingUserDomain, missingUserIdClients] of missingUserIds) {
-        if (!messageData.recipients.find(recipient => recipient.domain === missingUserDomain)) {
-          // no user from this domain is missing
-          continue;
-        }
+  private addMissingQualifiedClients(
+    messageData: ProtobufOTR.QualifiedNewOtrMessage,
+    reEncryptedPayloads: QualifiedOTRRecipients,
+  ): ProtobufOTR.QualifiedNewOtrMessage {
+    // walk through missing domain/user map
+    for (const [missingDomain, userClients] of Object.entries(reEncryptedPayloads)) {
+      // walk through missing user ids
+      for (const [missingUserId, missingClientIds] of Object.entries(userClients)) {
+        // walk through message recipients
+        for (const domain of messageData.recipients) {
+          // check if message recipients' domain is the same as the missing user's domain
+          if (domain.domain === missingDomain) {
+            // check if there is a recipient with same user id as the missing user's id
+            let userIndex = domain.entries?.findIndex(({user}) => bytesToUUID(user.uuid) === missingUserId);
+
+            if (userIndex === -1) {
+              // no recipient found, let's create it
+              userIndex =
+                domain.entries!.push({
+                  user: {
+                    uuid: uuidToBytes(missingUserId),
+                  },
+                }) - 1;
+            }
 
-        // walk through missing user ids
-        for (const [missingUserId, missingClientIds] of Object.entries(missingUserIdClients)) {
-          // walk through message recipients
-          for (const domain of messageData.recipients) {
-            // check if message recipients' domain is the same as the missing user's domain
-            if (domain.domain === missingUserDomain) {
-              // check if there is a recipient with same user id as the missing user's id
-              let userIndex = domain.entries?.findIndex(({user}) => bytesToUUID(user.uuid) === missingUserId);
-
-              if (userIndex === -1) {
-                // no recipient found, let's create it
-                userIndex =
-                  domain.entries!.push({
-                    user: {
-                      uuid: uuidToBytes(missingUserId),
-                    },
-                  }) - 1;
-              }
+            const missingUserUUID = domain.entries![userIndex!].user.uuid;
 
-              const missingUserUUID = domain.entries![userIndex!].user.uuid;
-
-              if (bytesToUUID(missingUserUUID) === missingUserId) {
-                for (const missingClientId of missingClientIds) {
-                  domain.entries![userIndex!].clients ||= [];
-                  domain.entries![userIndex!].clients?.push({
-                    client: {
-                      client: Long.fromString(missingClientId, 16),
-                    },
-                    text: reEncryptedPayloads[missingUserDomain][missingUserId][missingClientId],
-                  });
-                }
+            if (bytesToUUID(missingUserUUID) === missingUserId) {
+              for (const [missingClientId, missingClientPayload] of Object.entries(missingClientIds)) {
+                domain.entries![userIndex!].clients ||= [];
+                domain.entries![userIndex!].clients?.push({
+                  client: {
+                    client: Long.fromString(missingClientId, 16),
+                  },
+                  text: missingClientPayload,
+                });
               }
             }
           }