@wireapp/core 30.5.1 → 30.5.2

package/src/main/conversation/ConversationService/ConversationService.js

@@ -1,900 +0,0 @@
-"use strict";
-/*
- * Wire
- * Copyright (C) 2022 Wire Swiss GmbH
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConversationService = void 0;
-const conversation_1 = require("@wireapp/api-client/src/conversation");
-const data_1 = require("@wireapp/api-client/src/conversation/data");
-const protocol_messaging_1 = require("@wireapp/protocol-messaging");
-const conversation_2 = require("../../conversation/");
-const AssetCryptography_1 = require("../../cryptography/AssetCryptography");
-const TypePredicateUtil_1 = require("../../util/TypePredicateUtil");
-const MessageBuilder_1 = require("../message/MessageBuilder");
-const MessageService_1 = require("../message/MessageService");
-const MessageToProtoMapper_1 = require("../message/MessageToProtoMapper");
-const ConversationService_types_1 = require("./ConversationService.types");
-const bazinga64_1 = require("bazinga64");
-const mapQualifiedUserClientIdsToFullyQualifiedClientIds_1 = require("../../util/mapQualifiedUserClientIdsToFullyQualifiedClientIds");
-const mls_1 = require("../../mls");
-class ConversationService {
-    constructor(apiClient, cryptographyService, config, notificationService, mlsService) {
-        this.apiClient = apiClient;
-        this.config = config;
-        this.notificationService = notificationService;
-        this.mlsService = mlsService;
-        this.messageTimer = new conversation_2.MessageTimer();
-        this.messageService = new MessageService_1.MessageService(this.apiClient, cryptographyService);
-    }
-    createEphemeral(originalGenericMessage, expireAfterMillis) {
-        const ephemeralMessage = protocol_messaging_1.Ephemeral.create({
-            expireAfterMillis,
-            [originalGenericMessage.content]: originalGenericMessage[originalGenericMessage.content],
-        });
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.EPHEMERAL]: ephemeralMessage,
-            messageId: originalGenericMessage.messageId,
-        });
-        return genericMessage;
-    }
-    async getConversationQualifiedMembers(conversationId) {
-        const conversation = await this.apiClient.api.conversation.getConversation(conversationId);
-        /*
-         * If you are sending a message to a conversation, you have to include
-         * yourself in the list of users if you want to sync a message also to your
-         * other clients.
-         */
-        return conversation.members.others
-            .filter(member => !!member.qualified_id)
-            .map(member => member.qualified_id)
-            .concat(conversation.members.self.qualified_id);
-    }
-    /**
-     * Will generate a prekey bundle for specific users.
-     * If a QualifiedId array is given the bundle will contain all the clients from those users fetched from the server.
-     * If a QualifiedUserClients is provided then only the clients in the payload will be targeted (which could generate a ClientMismatch when sending messages)
-     *
-     * @param {QualifiedId[]|QualifiedUserClients} userIds - Targeted users.
-     * @returns {Promise<QualifiedUserPreKeyBundleMap}
-     */
-    async getQualifiedPreKeyBundle(userIds) {
-        let targets = [];
-        if (userIds) {
-            if ((0, TypePredicateUtil_1.isQualifiedIdArray)(userIds)) {
-                targets = userIds.map(id => ({ id }));
-            }
-            else {
-                targets = Object.entries(userIds).reduce((accumulator, [domain, userClients]) => {
-                    for (const userId in userClients) {
-                        accumulator.push({ id: { id: userId, domain }, clients: userClients[userId] });
-                    }
-                    return accumulator;
-                }, []);
-            }
-        }
-        const preKeys = await Promise.all(targets.map(async ({ id: userId, clients }) => {
-            const prekeyBundle = await this.apiClient.api.user.getUserPreKeys(userId);
-            // We filter the clients that should not receive the message (if a QualifiedUserClients was given as parameter)
-            const userClients = clients
-                ? prekeyBundle.clients.filter(client => clients.includes(client.client))
-                : prekeyBundle.clients;
-            return { user: userId, clients: userClients };
-        }));
-        return preKeys.reduce((bundleMap, qualifiedPrekey) => {
-            var _a, _b, _c;
-            bundleMap[_a = qualifiedPrekey.user.domain] || (bundleMap[_a] = {});
-            for (const client of qualifiedPrekey.clients) {
-                (_b = bundleMap[qualifiedPrekey.user.domain])[_c = qualifiedPrekey.user.id] || (_b[_c] = {});
-                bundleMap[qualifiedPrekey.user.domain][qualifiedPrekey.user.id][client.client] = client.prekey;
-            }
-            return bundleMap;
-        }, {});
-    }
-    async getPreKeyBundleMap(conversationId, userIds) {
-        let members = [];
-        if (userIds) {
-            if ((0, TypePredicateUtil_1.isStringArray)(userIds)) {
-                members = userIds;
-            }
-            else if ((0, TypePredicateUtil_1.isUserClients)(userIds)) {
-                members = Object.keys(userIds);
-            }
-        }
-        if (!members.length) {
-            const conversation = await this.apiClient.api.conversation.getConversation(conversationId);
-            /*
-             * If you are sending a message to a conversation, you have to include
-             * yourself in the list of users if you want to sync a message also to your
-             * other clients.
-             */
-            members = conversation.members.others.map(member => member.id).concat(conversation.members.self.id);
-        }
-        const preKeys = await Promise.all(members.map(member => this.apiClient.api.user.getUserPreKeys(member)));
-        return preKeys.reduce((bundleMap, bundle) => {
-            const userId = bundle.user;
-            bundleMap[userId] || (bundleMap[userId] = {});
-            for (const client of bundle.clients) {
-                bundleMap[userId][client.client] = client.prekey;
-            }
-            return bundleMap;
-        }, {});
-    }
-    async getSelfConversationId() {
-        if (!this.selfConversationId) {
-            const { userId } = this.apiClient.context;
-            const { qualified_id, id } = await this.apiClient.api.conversation.getConversation(userId);
-            const domain = this.config.useQualifiedIds ? qualified_id.domain : '';
-            this.selfConversationId = { id, domain };
-        }
-        return this.selfConversationId;
-    }
-    async getQualifiedRecipientsForConversation(conversationId, userIds) {
-        if ((0, TypePredicateUtil_1.isQualifiedUserClients)(userIds)) {
-            return userIds;
-        }
-        const recipientIds = userIds || (await this.getConversationQualifiedMembers(conversationId));
-        return this.getQualifiedPreKeyBundle(recipientIds);
-    }
-    async getRecipientsForConversation(conversationId, userIds) {
-        if ((0, TypePredicateUtil_1.isUserClients)(userIds)) {
-            return userIds;
-        }
-        return this.getPreKeyBundleMap(conversationId, userIds);
-    }
-    /**
-     * Sends a message to a conversation
-     *
-     * @param sendingClientId The clientId from which the message is sent
-     * @param conversationId The conversation in which to send the message
-     * @param genericMessage The payload of the message to send
-     * @return Resolves with the message sending status from backend
-     */
-    async sendGenericMessage(sendingClientId, conversationId, genericMessage, { conversationDomain, userIds, nativePush, sendAsProtobuf, onClientMismatch, targetMode = ConversationService_types_1.MessageTargetMode.NONE, } = {}) {
-        const plainText = protocol_messaging_1.GenericMessage.encode(genericMessage).finish();
-        if (targetMode !== ConversationService_types_1.MessageTargetMode.NONE && !userIds) {
-            throw new Error('Cannot send targetted message when no userIds are given');
-        }
-        if (conversationDomain && this.config.useQualifiedIds) {
-            if ((0, TypePredicateUtil_1.isStringArray)(userIds) || (0, TypePredicateUtil_1.isUserClients)(userIds)) {
-                throw new Error('Invalid userIds option for sending to federated backend');
-            }
-            const recipients = await this.getQualifiedRecipientsForConversation({ id: conversationId, domain: conversationDomain }, userIds);
-            let reportMissing;
-            if (targetMode === ConversationService_types_1.MessageTargetMode.NONE) {
-                reportMissing = (0, TypePredicateUtil_1.isQualifiedUserClients)(userIds); // we want to check mismatch in case the consumer gave an exact list of users/devices
-            }
-            else if (targetMode === ConversationService_types_1.MessageTargetMode.USERS) {
-                reportMissing = this.extractQualifiedUserIds(userIds);
-            }
-            else {
-                // in case the message is fully targetted at user/client pairs, we do not want to report the missing clients or users at all
-                reportMissing = false;
-            }
-            return this.messageService.sendFederatedMessage(sendingClientId, recipients, plainText, {
-                conversationId: { id: conversationId, domain: conversationDomain },
-                nativePush,
-                reportMissing,
-                onClientMismatch: mismatch => onClientMismatch === null || onClientMismatch === void 0 ? void 0 : onClientMismatch(mismatch, false),
-            });
-        }
-        if ((0, TypePredicateUtil_1.isQualifiedIdArray)(userIds) || (0, TypePredicateUtil_1.isQualifiedUserClients)(userIds)) {
-            throw new Error('Invalid userIds option for sending');
-        }
-        const recipients = await this.getRecipientsForConversation(conversationId, userIds);
-        let reportMissing;
-        if (targetMode === ConversationService_types_1.MessageTargetMode.NONE) {
-            reportMissing = (0, TypePredicateUtil_1.isUserClients)(userIds); // we want to check mismatch in case the consumer gave an exact list of users/devices
-        }
-        else if (targetMode === ConversationService_types_1.MessageTargetMode.USERS) {
-            reportMissing = this.extractUserIds(userIds);
-        }
-        else {
-            // in case the message is fully targetted at user/client pairs, we do not want to report the missing clients or users at all
-            reportMissing = false;
-        }
-        return this.messageService.sendMessage(sendingClientId, recipients, plainText, {
-            conversationId,
-            sendAsProtobuf,
-            nativePush,
-            reportMissing,
-            onClientMismatch: mistmatch => onClientMismatch === null || onClientMismatch === void 0 ? void 0 : onClientMismatch(mistmatch, false),
-        });
-    }
-    extractUserIds(userIds) {
-        if ((0, TypePredicateUtil_1.isUserClients)(userIds)) {
-            return Object.keys(userIds);
-        }
-        return userIds;
-    }
-    extractQualifiedUserIds(userIds) {
-        if ((0, TypePredicateUtil_1.isQualifiedUserClients)(userIds)) {
-            return Object.entries(userIds).reduce((ids, [domain, userClients]) => {
-                return ids.concat(Object.keys(userClients).map(userId => ({ domain, id: userId })));
-            }, []);
-        }
-        return userIds;
-    }
-    generateButtonActionGenericMessage(payloadBundle) {
-        return protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.BUTTON_ACTION]: protocol_messaging_1.ButtonAction.create(payloadBundle.content),
-            messageId: payloadBundle.id,
-        });
-    }
-    generateButtonActionConfirmationGenericMessage(payloadBundle) {
-        return protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.BUTTON_ACTION_CONFIRMATION]: protocol_messaging_1.ButtonActionConfirmation.create(payloadBundle.content),
-            messageId: payloadBundle.id,
-        });
-    }
-    generateCompositeGenericMessage(payloadBundle) {
-        return protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.COMPOSITE]: protocol_messaging_1.Composite.create(payloadBundle.content),
-            messageId: payloadBundle.id,
-        });
-    }
-    generateConfirmationGenericMessage(payloadBundle) {
-        const content = protocol_messaging_1.Confirmation.create(payloadBundle.content);
-        return protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.CONFIRMATION]: content,
-            messageId: payloadBundle.id,
-        });
-    }
-    generateEditedTextGenericMessage(payloadBundle) {
-        const editedMessage = protocol_messaging_1.MessageEdit.create({
-            replacingMessageId: payloadBundle.content.originalMessageId,
-            text: MessageToProtoMapper_1.MessageToProtoMapper.mapText(payloadBundle),
-        });
-        return protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.EDITED]: editedMessage,
-            messageId: payloadBundle.id,
-        });
-    }
-    generateFileDataGenericMessage(payloadBundle) {
-        if (!payloadBundle.content) {
-            throw new Error('No content for sendFileData provided.');
-        }
-        const { asset, expectsReadConfirmation, legalHoldStatus } = payloadBundle.content;
-        const remoteData = protocol_messaging_1.Asset.RemoteData.create({
-            assetId: asset.key,
-            assetToken: asset.token,
-            otrKey: asset.keyBytes,
-            sha256: asset.sha256,
-            assetDomain: asset.domain,
-        });
-        const assetMessage = protocol_messaging_1.Asset.create({
-            expectsReadConfirmation,
-            legalHoldStatus,
-            uploaded: remoteData,
-        });
-        assetMessage.status = conversation_2.AssetTransferState.UPLOADED;
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.ASSET]: assetMessage,
-            messageId: payloadBundle.id,
-        });
-        const expireAfterMillis = this.messageTimer.getMessageTimer(payloadBundle.conversation);
-        return expireAfterMillis > 0 ? this.createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
-    }
-    generateFileMetaDataGenericMessage(payloadBundle) {
-        if (!payloadBundle.content) {
-            throw new Error('No content for sendFileMetaData provided.');
-        }
-        const { expectsReadConfirmation, legalHoldStatus, metaData } = payloadBundle.content;
-        const original = protocol_messaging_1.Asset.Original.create({
-            audio: metaData.audio,
-            mimeType: metaData.type,
-            name: metaData.name,
-            size: metaData.length,
-            video: metaData.video,
-            image: metaData.image,
-        });
-        const assetMessage = protocol_messaging_1.Asset.create({
-            expectsReadConfirmation,
-            legalHoldStatus,
-            original,
-        });
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.ASSET]: assetMessage,
-            messageId: payloadBundle.id,
-        });
-        const expireAfterMillis = this.messageTimer.getMessageTimer(payloadBundle.conversation);
-        return expireAfterMillis > 0 ? this.createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
-    }
-    generateFileAbortGenericMessage(payloadBundle) {
-        if (!payloadBundle.content) {
-            throw new Error('No content for sendFileAbort provided.');
-        }
-        const { expectsReadConfirmation, legalHoldStatus, reason } = payloadBundle.content;
-        const assetMessage = protocol_messaging_1.Asset.create({
-            expectsReadConfirmation,
-            legalHoldStatus,
-            notUploaded: reason,
-        });
-        assetMessage.status = conversation_2.AssetTransferState.NOT_UPLOADED;
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.ASSET]: assetMessage,
-            messageId: payloadBundle.id,
-        });
-        const expireAfterMillis = this.messageTimer.getMessageTimer(payloadBundle.conversation);
-        return expireAfterMillis > 0 ? this.createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
-    }
-    generateAsset(payloadBundle) {
-        if (!payloadBundle.content) {
-            throw new Error('No content for sendImage provided.');
-        }
-        const { asset, expectsReadConfirmation, image, legalHoldStatus } = payloadBundle.content;
-        const imageMetadata = protocol_messaging_1.Asset.ImageMetaData.create({
-            height: image.height,
-            width: image.width,
-        });
-        const original = protocol_messaging_1.Asset.Original.create({
-            [conversation_2.GenericMessageType.IMAGE]: imageMetadata,
-            mimeType: image.type,
-            name: null,
-            size: image.data.length,
-        });
-        const remoteData = protocol_messaging_1.Asset.RemoteData.create({
-            assetId: asset.key,
-            assetToken: asset.token,
-            assetDomain: asset.domain,
-            otrKey: asset.keyBytes,
-            sha256: asset.sha256,
-        });
-        const assetMessage = protocol_messaging_1.Asset.create({
-            expectsReadConfirmation,
-            legalHoldStatus,
-            original,
-            uploaded: remoteData,
-        });
-        assetMessage.status = conversation_2.AssetTransferState.UPLOADED;
-        return assetMessage;
-    }
-    generateImageGenericMessage(payloadBundle) {
-        const imageAsset = this.generateAsset(payloadBundle);
-        let genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.ASSET]: imageAsset,
-            messageId: payloadBundle.id,
-        });
-        const expireAfterMillis = this.messageTimer.getMessageTimer(payloadBundle.conversation);
-        if (expireAfterMillis) {
-            genericMessage = this.createEphemeral(genericMessage, expireAfterMillis);
-        }
-        return { genericMessage, content: imageAsset };
-    }
-    generateLocationGenericMessage(payloadBundle) {
-        const { expectsReadConfirmation, latitude, legalHoldStatus, longitude, name, zoom } = payloadBundle.content;
-        const locationMessage = protocol_messaging_1.Location.create({
-            expectsReadConfirmation,
-            latitude,
-            legalHoldStatus,
-            longitude,
-            name,
-            zoom,
-        });
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.LOCATION]: locationMessage,
-            messageId: payloadBundle.id,
-        });
-        const expireAfterMillis = this.messageTimer.getMessageTimer(payloadBundle.conversation);
-        return expireAfterMillis > 0 ? this.createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
-    }
-    generatePingGenericMessage(payloadBundle) {
-        const content = protocol_messaging_1.Knock.create(payloadBundle.content);
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.KNOCK]: content,
-            messageId: payloadBundle.id,
-        });
-        const expireAfterMillis = this.messageTimer.getMessageTimer(payloadBundle.conversation);
-        return expireAfterMillis > 0 ? this.createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
-    }
-    generateReactionGenericMessage(payloadBundle) {
-        const { legalHoldStatus, originalMessageId, type } = payloadBundle.content;
-        const reaction = protocol_messaging_1.Reaction.create({
-            emoji: type,
-            legalHoldStatus,
-            messageId: originalMessageId,
-        });
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.REACTION]: reaction,
-            messageId: payloadBundle.id,
-        });
-        return genericMessage;
-    }
-    generateSessionResetGenericMessage(payloadBundle) {
-        return protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.CLIENT_ACTION]: protocol_messaging_1.ClientAction.RESET_SESSION,
-            messageId: payloadBundle.id,
-        });
-    }
-    generateCallGenericMessage(payloadBundle) {
-        const callMessage = protocol_messaging_1.Calling.create({
-            content: payloadBundle.content,
-        });
-        return protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.CALLING]: callMessage,
-            messageId: payloadBundle.id,
-        });
-    }
-    generateTextGenericMessage(payloadBundle) {
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            messageId: payloadBundle.id,
-            [conversation_2.GenericMessageType.TEXT]: MessageToProtoMapper_1.MessageToProtoMapper.mapText(payloadBundle),
-        });
-        const expireAfterMillis = this.messageTimer.getMessageTimer(payloadBundle.conversation);
-        return expireAfterMillis > 0 ? this.createEphemeral(genericMessage, expireAfterMillis) : genericMessage;
-    }
-    async clearConversation(conversationId, timestamp = new Date(), messageId = MessageBuilder_1.MessageBuilder.createId(), sendAsProtobuf) {
-        if (timestamp instanceof Date) {
-            timestamp = timestamp.getTime();
-        }
-        const content = {
-            clearedTimestamp: timestamp,
-            conversationId,
-        };
-        const clearedMessage = protocol_messaging_1.Cleared.create(content);
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.CLEARED]: clearedMessage,
-            messageId,
-        });
-        const { id: selfConversationId, domain } = await this.getSelfConversationId();
-        await this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, {
-            conversationDomain: domain,
-            sendAsProtobuf,
-        });
-        return {
-            content,
-            conversation: conversationId,
-            from: this.apiClient.context.userId,
-            id: messageId,
-            messageTimer: 0,
-            source: conversation_2.PayloadBundleSource.LOCAL,
-            state: conversation_2.PayloadBundleState.OUTGOING_SENT,
-            timestamp: Date.now(),
-            type: conversation_2.PayloadBundleType.CONVERSATION_CLEAR,
-        };
-    }
-    /**
-     * Sends a LastRead message to the current user's self conversation.
-     * This will allow all the user's devices to compute which messages are unread
-     *
-     * @param conversationId The conversation which has been read
-     * @param lastReadTimestamp The timestamp at which the conversation was read
-     * @param sendingOptions?
-     * @return Resolves when the message has been sent
-     */
-    async sendLastRead(conversationId, lastReadTimestamp, sendingOptions) {
-        const lastRead = new protocol_messaging_1.LastRead({
-            conversationId,
-            lastReadTimestamp,
-        });
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.LAST_READ]: lastRead,
-            messageId: MessageBuilder_1.MessageBuilder.createId(),
-        });
-        const { id: selfConversationId, domain: selfConversationDomain } = await this.getSelfConversationId();
-        return this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, Object.assign({ conversationDomain: selfConversationDomain }, sendingOptions));
-    }
-    /**
-     * Syncs all self user's devices with the countly id
-     *
-     * @param countlyId The countly id of the current device
-     * @param sendingOptions?
-     * @return Resolves when the message has been sent
-     */
-    async sendCountlySync(countlyId, sendingOptions) {
-        const { id: selfConversationId, domain: selfConversationDomain } = await this.getSelfConversationId();
-        const dataTransfer = new protocol_messaging_1.DataTransfer({
-            trackingIdentifier: {
-                identifier: countlyId,
-            },
-        });
-        const genericMessage = new protocol_messaging_1.GenericMessage({
-            [conversation_2.GenericMessageType.DATA_TRANSFER]: dataTransfer,
-            messageId: MessageBuilder_1.MessageBuilder.createId(),
-        });
-        return this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, Object.assign({ conversationDomain: selfConversationDomain }, sendingOptions));
-    }
-    /**
-     * Get a fresh list from backend of clients for all the participants of the conversation.
-     * @param {string} conversationId
-     * @param {string} conversationDomain? - If given will send the message to the new qualified endpoint
-     */
-    async getAllParticipantsClients(conversationId, conversationDomain) {
-        const qualifiedMembers = await this.getConversationQualifiedMembers(conversationDomain ? { id: conversationId, domain: conversationDomain } : conversationId);
-        const allClients = await this.apiClient.api.user.postListClients({ qualified_users: qualifiedMembers });
-        const qualifiedUserClients = {};
-        Object.entries(allClients.qualified_user_map).map(([domain, userClientMap]) => Object.entries(userClientMap).map(async ([userId, clients]) => {
-            qualifiedUserClients[domain] || (qualifiedUserClients[domain] = {});
-            qualifiedUserClients[domain][userId] = clients.map(client => client.id);
-        }));
-        return qualifiedUserClients;
-    }
-    async deleteMessageLocal(conversationId, messageIdToHide, sendAsProtobuf, conversationDomain) {
-        const messageId = MessageBuilder_1.MessageBuilder.createId();
-        const content = protocol_messaging_1.MessageHide.create({
-            conversationId,
-            messageId: messageIdToHide,
-        });
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.HIDDEN]: content,
-            messageId,
-        });
-        const { id: selfConversationId } = await this.getSelfConversationId();
-        await this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, {
-            sendAsProtobuf,
-            conversationDomain,
-        });
-        return {
-            content,
-            conversation: conversationId,
-            from: this.apiClient.context.userId,
-            id: messageId,
-            messageTimer: this.messageTimer.getMessageTimer(conversationId),
-            source: conversation_2.PayloadBundleSource.LOCAL,
-            state: conversation_2.PayloadBundleState.OUTGOING_SENT,
-            timestamp: Date.now(),
-            type: conversation_2.PayloadBundleType.MESSAGE_HIDE,
-        };
-    }
-    async deleteMessageEveryone(conversationId, messageIdToDelete, userIds, sendAsProtobuf, conversationDomain, callbacks) {
-        var _a, _b;
-        const messageId = MessageBuilder_1.MessageBuilder.createId();
-        const content = protocol_messaging_1.MessageDelete.create({
-            messageId: messageIdToDelete,
-        });
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            [conversation_2.GenericMessageType.DELETED]: content,
-            messageId,
-        });
-        (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onStart) === null || _a === void 0 ? void 0 : _a.call(callbacks, genericMessage);
-        const response = await this.sendGenericMessage(this.apiClient.validatedClientId, conversationId, genericMessage, {
-            userIds,
-            sendAsProtobuf,
-            conversationDomain,
-        });
-        (_b = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onSuccess) === null || _b === void 0 ? void 0 : _b.call(callbacks, genericMessage, response === null || response === void 0 ? void 0 : response.time);
-        return {
-            content,
-            conversation: conversationId,
-            from: this.apiClient.context.userId,
-            id: messageId,
-            messageTimer: this.messageTimer.getMessageTimer(conversationId),
-            source: conversation_2.PayloadBundleSource.LOCAL,
-            state: conversation_2.PayloadBundleState.OUTGOING_SENT,
-            timestamp: Date.now(),
-            type: conversation_2.PayloadBundleType.MESSAGE_DELETE,
-        };
-    }
-    leaveConversation(conversationId) {
-        if (!this.apiClient.context || !this.apiClient.context.userId || !this.apiClient.context.domain) {
-            throw new Error('Cannot leave conversation without a userId and domain');
-        }
-        return this.apiClient.api.conversation.deleteMember(conversationId, {
-            domain: this.apiClient.context.domain,
-            id: this.apiClient.context.userId,
-        });
-    }
-    leaveMLSConversation(conversationId) {
-        return this.leaveConversation(conversationId);
-    }
-    /**
-     * @depricated seems not to be used and is outdated. use leaveConversation instead
-     */
-    async leaveConversations(conversationIds) {
-        if (!conversationIds) {
-            const conversation = await this.getConversations();
-            conversationIds = conversation
-                .filter(conversation => conversation.type === conversation_1.CONVERSATION_TYPE.REGULAR)
-                .map(conversation => conversation.id);
-        }
-        return Promise.all(conversationIds.map(conversationId => { var _a, _b; return this.leaveConversation({ id: conversationId, domain: (_b = (_a = this.apiClient.context) === null || _a === void 0 ? void 0 : _a.domain) !== null && _b !== void 0 ? _b : '' }); }));
-    }
-    createProteusConversation(conversationData, otherUserIds) {
-        let payload;
-        if (typeof conversationData === 'string') {
-            const ids = typeof otherUserIds === 'string' ? [otherUserIds] : otherUserIds;
-            payload = {
-                name: conversationData,
-                receipt_mode: null,
-                users: ids !== null && ids !== void 0 ? ids : [],
-            };
-        }
-        else {
-            payload = conversationData;
-        }
-        return this.apiClient.api.conversation.postConversation(payload);
-    }
-    async getConversations(conversationIds) {
-        if (!conversationIds || !conversationIds.length) {
-            return this.apiClient.api.conversation.getAllConversations();
-        }
-        if (typeof conversationIds === 'string') {
-            return this.apiClient.api.conversation.getConversation(conversationIds);
-        }
-        return this.apiClient.api.conversation.getConversationsByIds(conversationIds);
-    }
-    async getAsset({ assetId, assetToken, otrKey, sha256 }) {
-        const request = this.apiClient.api.asset.getAssetV3(assetId, assetToken);
-        const encryptedBuffer = (await request.response).buffer;
-        return (0, AssetCryptography_1.decryptAsset)({
-            cipherText: new Uint8Array(encryptedBuffer),
-            keyBytes: otrKey,
-            sha256: sha256,
-        });
-    }
-    async getUnencryptedAsset(assetId, assetToken) {
-        const request = await this.apiClient.api.asset.getAssetV3(assetId, assetToken);
-        return (await request.response).buffer;
-    }
-    async addUsersToProteusConversation({ conversationId, qualifiedUserIds }) {
-        return this.apiClient.api.conversation.postMembers(conversationId, qualifiedUserIds);
-    }
-    async removeUserFromProteusConversation(conversationId, userId) {
-        return this.apiClient.api.conversation.deleteMember(conversationId, userId);
-    }
-    async sendProteusMessage(params, genericMessage, content) {
-        var _a;
-        const { userIds, sendAsProtobuf, conversationDomain, nativePush, targetMode, payload, onClientMismatch, onSuccess } = params;
-        const response = await this.sendGenericMessage(this.apiClient.validatedClientId, payload.conversation, genericMessage, {
-            userIds,
-            sendAsProtobuf,
-            conversationDomain,
-            nativePush,
-            targetMode,
-            onClientMismatch,
-        });
-        if (!response.errored) {
-            if (!this.isClearFromMismatch(response)) {
-                // We warn the consumer that there is a mismatch that did not prevent message sending
-                await (onClientMismatch === null || onClientMismatch === void 0 ? void 0 : onClientMismatch(response, true));
-            }
-            onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(genericMessage, response.time);
-        }
-        return Object.assign(Object.assign({}, payload), { content, messageTimer: ((_a = genericMessage.ephemeral) === null || _a === void 0 ? void 0 : _a.expireAfterMillis) || 0, state: response.errored ? conversation_2.PayloadBundleState.CANCELLED : conversation_2.PayloadBundleState.OUTGOING_SENT });
-    }
-    /**
-     * Sends a message to a conversation
-     * @return resolves with the sent message
-     */
-    async send(params) {
-        function isMLS(params) {
-            return params.protocol === conversation_1.ConversationProtocol.MLS;
-        }
-        const { payload, onStart } = params;
-        const { genericMessage, content } = this.generateGenericMessage(payload);
-        if ((await (onStart === null || onStart === void 0 ? void 0 : onStart(genericMessage))) === false) {
-            // If the onStart call returns false, it means the consumer wants to cancel the message sending
-            return Object.assign(Object.assign({}, payload), { state: conversation_2.PayloadBundleState.CANCELLED });
-        }
-        return isMLS(params)
-            ? this.sendMLSMessage(params, genericMessage, content)
-            : this.sendProteusMessage(params, genericMessage, content);
-    }
-    sendTypingStart(conversationId) {
-        return this.apiClient.api.conversation.postTyping(conversationId, { status: data_1.CONVERSATION_TYPING.STARTED });
-    }
-    sendTypingStop(conversationId) {
-        return this.apiClient.api.conversation.postTyping(conversationId, { status: data_1.CONVERSATION_TYPING.STOPPED });
-    }
-    setConversationMutedStatus(conversationId, status, muteTimestamp) {
-        if (typeof muteTimestamp === 'number') {
-            muteTimestamp = new Date(muteTimestamp);
-        }
-        const payload = {
-            otr_muted_ref: muteTimestamp.toISOString(),
-            otr_muted_status: status,
-        };
-        return this.apiClient.api.conversation.putMembershipProperties(conversationId, payload);
-    }
-    toggleArchiveConversation(conversationId, archived, archiveTimestamp = new Date()) {
-        if (typeof archiveTimestamp === 'number') {
-            archiveTimestamp = new Date(archiveTimestamp);
-        }
-        const payload = {
-            otr_archived: archived,
-            otr_archived_ref: archiveTimestamp.toISOString(),
-        };
-        return this.apiClient.api.conversation.putMembershipProperties(conversationId, payload);
-    }
-    setMemberConversationRole(conversationId, userId, conversationRole) {
-        return this.apiClient.api.conversation.putOtherMember(userId, conversationId, {
-            conversation_role: conversationRole,
-        });
-    }
-    isClearFromMismatch(mismatch) {
-        const hasMissing = Object.keys(mismatch.missing || {}).length > 0;
-        const hasDeleted = Object.keys(mismatch.deleted || {}).length > 0;
-        const hasRedundant = Object.keys(mismatch.redundant || {}).length > 0;
-        const hasFailed = Object.keys(mismatch.failed_to_send || {}).length > 0;
-        return !hasMissing && !hasDeleted && !hasRedundant && !hasFailed;
-    }
-    generateGenericMessage(payload) {
-        let genericMessage;
-        const content = payload.content;
-        switch (payload.type) {
-            case conversation_2.PayloadBundleType.ASSET:
-                genericMessage = this.generateFileDataGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.ASSET_ABORT:
-                genericMessage = this.generateFileAbortGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.ASSET_META:
-                genericMessage = this.generateFileMetaDataGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.ASSET_IMAGE:
-                return this.generateImageGenericMessage(payload);
-            case conversation_2.PayloadBundleType.BUTTON_ACTION:
-                genericMessage = this.generateButtonActionGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.BUTTON_ACTION_CONFIRMATION:
-                genericMessage = this.generateButtonActionConfirmationGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.CALL:
-                genericMessage = this.generateCallGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.CLIENT_ACTION: {
-                if (payload.content.clientAction !== protocol_messaging_1.ClientAction.RESET_SESSION) {
-                    throw new Error(`No send method implemented for "${payload.type}" and ClientAction "${payload.content}".`);
-                }
-                genericMessage = this.generateSessionResetGenericMessage(payload);
-                return { genericMessage, content };
-            }
-            case conversation_2.PayloadBundleType.COMPOSITE:
-                genericMessage = this.generateCompositeGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.CONFIRMATION:
-                genericMessage = this.generateConfirmationGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.LOCATION:
-                genericMessage = this.generateLocationGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.MESSAGE_EDIT:
-                genericMessage = this.generateEditedTextGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.PING:
-                genericMessage = this.generatePingGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.REACTION:
-                genericMessage = this.generateReactionGenericMessage(payload);
-                return { genericMessage, content };
-            case conversation_2.PayloadBundleType.TEXT:
-                genericMessage = this.generateTextGenericMessage(payload);
-                return { genericMessage, content };
-            /**
-             * ToDo: Create Generic implementation for everything else
-             */
-            default:
-                throw new Error(`No send method implemented for "${payload['type']}".`);
-        }
-    }
-    /**
-     *   ###############################################
-     *   ################ MLS Functions ################
-     *   ###############################################
-     */
-    async createMLSConversation(conversationData) {
-        /**
-         * @note For creating MLS conversations the users & qualified_users
-         * field must be empty as backend is not aware which users
-         * are in a MLS conversation because of the MLS architecture.
-         */
-        const newConversation = await this.apiClient.api.conversation.postConversation(Object.assign(Object.assign({}, conversationData), { users: undefined, qualified_users: undefined }));
-        const { group_id: groupId, qualified_id: qualifiedId } = newConversation;
-        if (!groupId) {
-            throw new Error('No group_id found in response which is required for creating MLS conversations.');
-        }
-        const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        const { qualified_users: qualifiedUsers = [], selfUserId } = conversationData;
-        if (!selfUserId) {
-            throw new Error('You need to pass self user qualified id in order to create an MLS conversation');
-        }
-        await this.mlsService.createConversation(groupIdDecodedFromBase64);
-        const coreCryptoKeyPackagesPayload = await this.mlsService.getKeyPackagesPayload([
-            {
-                id: selfUserId.id,
-                domain: selfUserId.domain,
-                /**
-                 * we should skip fetching key packages for current self client,
-                 * it's already added by the backend on the group creation time
-                 */
-                skipOwn: conversationData.creator_client,
-            },
-            ...qualifiedUsers,
-        ]);
-        const response = await this.mlsService.addUsersToExistingConversation(groupIdDecodedFromBase64, coreCryptoKeyPackagesPayload);
-        await this.notificationService.saveConversationGroupId(newConversation);
-        //We store the info when conversation (along with key material) was created, so we will know when to renew it
-        const groupCreationTimeStamp = new Date().getTime();
-        await this.notificationService.storeLastKeyMaterialUpdateDate({
-            previousUpdateDate: groupCreationTimeStamp,
-            groupId,
-        });
-        // We fetch the fresh version of the conversation created on backend with the newly added users
-        const conversation = await this.getConversations(qualifiedId.id);
-        return {
-            events: (response === null || response === void 0 ? void 0 : response.events) || [],
-            conversation,
-        };
-    }
-    async sendMLSMessage(params, genericMessage, content) {
-        var _a, _b;
-        const { groupId, onSuccess, payload } = params;
-        const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        // immediately execute pending commits before sending the message
-        await this.notificationService.commitPendingProposals({ groupId });
-        const encrypted = await this.mlsService.encryptMessage(groupIdBytes, protocol_messaging_1.GenericMessage.encode(genericMessage).finish());
-        try {
-            const { time = '' } = await this.apiClient.api.conversation.postMlsMessage(encrypted);
-            onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(genericMessage, (time === null || time === void 0 ? void 0 : time.length) > 0 ? time : new Date().toISOString());
-            return Object.assign(Object.assign({}, payload), { content, messageTimer: ((_a = genericMessage.ephemeral) === null || _a === void 0 ? void 0 : _a.expireAfterMillis) || 0, state: conversation_2.PayloadBundleState.OUTGOING_SENT });
-        }
-        catch (_c) {
-            return Object.assign(Object.assign({}, payload), { content, messageTimer: ((_b = genericMessage.ephemeral) === null || _b === void 0 ? void 0 : _b.expireAfterMillis) || 0, state: conversation_2.PayloadBundleState.CANCELLED });
-        }
-    }
-    async addUsersToMLSConversation({ qualifiedUserIds, groupId, conversationId, }) {
-        const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        const coreCryptoKeyPackagesPayload = await this.mlsService.getKeyPackagesPayload([...qualifiedUserIds]);
-        const response = await this.mlsService.addUsersToExistingConversation(groupIdDecodedFromBase64, coreCryptoKeyPackagesPayload);
-        const conversation = await this.getConversations(conversationId.id);
-        return {
-            events: (response === null || response === void 0 ? void 0 : response.events) || [],
-            conversation,
-        };
-    }
-    async storeLastKeyMaterialUpdateDateWithCurrentTime(groupId) {
-        const currentTime = new Date().getTime();
-        await this.notificationService.storeLastKeyMaterialUpdateDate({ groupId, previousUpdateDate: currentTime });
-    }
-    async removeUsersFromMLSConversation({ groupId, conversationId, qualifiedUserIds, }) {
-        const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-        const clientsToRemove = await this.apiClient.api.user.postListClients({ qualified_users: qualifiedUserIds });
-        const fullyQualifiedClientIds = (0, mapQualifiedUserClientIdsToFullyQualifiedClientIds_1.mapQualifiedUserClientIdsToFullyQualifiedClientIds)(clientsToRemove.qualified_user_map);
-        const messageResponse = await this.mlsService.removeClientsFromConversation(groupIdDecodedFromBase64, fullyQualifiedClientIds);
-        //key material gets updated after removing a user from the group, so we can reset last key update time value in the store
-        await this.storeLastKeyMaterialUpdateDateWithCurrentTime(groupId);
-        const conversation = await this.getConversations(conversationId.id);
-        return {
-            events: (messageResponse === null || messageResponse === void 0 ? void 0 : messageResponse.events) || [],
-            conversation,
-        };
-    }
-    /**
-     * Will send an external proposal for the current device to join a specific conversation.
-     * In order for the external proposal to be sent correctly, the underlying mls conversation needs to be in a non-established state
-     * @param conversationGroupId The conversation to join
-     * @param epoch The current epoch of the local conversation
-     */
-    async sendExternalJoinProposal(conversationGroupId, epoch) {
-        const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(conversationGroupId).asBytes;
-        const externalProposal = await this.mlsService.newExternalProposal(0 /* Add */, {
-            epoch,
-            conversationId: groupIdDecodedFromBase64,
-        });
-        await this.apiClient.api.conversation.postMlsMessage(
-        //@todo: it's temporary - we wait for core-crypto fix to return the actual Uint8Array instead of regular array
-        (0, mls_1.optionalToUint8Array)(externalProposal));
-        //We store the info when user was added (and key material was created), so we will know when to renew it
-        await this.storeLastKeyMaterialUpdateDateWithCurrentTime(conversationGroupId);
-    }
-    async isMLSConversationEstablished(conversationGroupId) {
-        const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(conversationGroupId).asBytes;
-        return this.mlsService.conversationExists(groupIdDecodedFromBase64);
-    }
-}
-exports.ConversationService = ConversationService;
-//# sourceMappingURL=ConversationService.js.map