@wireapp/core 31.1.3 → 31.1.4

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

@@ -0,0 +1,584 @@
+"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 core_crypto_1 = require("@wireapp/core-crypto");
+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 ConversationService_types_1 = require("./ConversationService.types");
+const bazinga64_1 = require("bazinga64");
+const fullyQualifiedClientIdUtils_1 = require("../../util/fullyQualifiedClientIdUtils");
+const mls_1 = require("../../mls");
+const messageSender_1 = require("../message/messageSender");
+const messageGenerator_1 = require("./messageGenerator");
+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);
+    }
+    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;
+    }
+    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.
+     * This is a hacky way of getting all the clients for a conversation.
+     * The idea is to send an empty message to the backend to absolutely no users and let backend reply with a mismatch error.
+     * We then get the missing members in the mismatch, that is our fresh list of participants' clients.
+     *
+     * @deprecated
+     * @param {string} conversationId
+     * @param {string} conversationDomain? - If given will send the message to the new qualified endpoint
+     */
+    getAllParticipantsClients(conversationId, conversationDomain) {
+        const sendingClientId = this.apiClient.validatedClientId;
+        const recipients = {};
+        const text = new Uint8Array();
+        return new Promise(async (resolve) => {
+            const onClientMismatch = (mismatch) => {
+                resolve(mismatch.missing);
+                // When the mismatch happens, we ask the messageService to cancel the sending
+                return false;
+            };
+            if (conversationDomain && this.config.useQualifiedIds) {
+                await this.messageService.sendFederatedMessage(sendingClientId, recipients, text, {
+                    conversationId: { id: conversationId, domain: conversationDomain },
+                    onClientMismatch,
+                    reportMissing: true,
+                });
+            }
+            else {
+                await this.messageService.sendMessage(sendingClientId, recipients, text, {
+                    conversationId,
+                    onClientMismatch,
+                });
+            }
+        });
+    }
+    /**
+     * Get a fresh list from backend of clients for all the participants of the conversation.
+     * @fixme there are some case where this method is not enough to detect removed devices
+     * @param {string} conversationId
+     * @param {string} conversationDomain? - If given will send the message to the new qualified endpoint
+     */
+    async fetchAllParticipantsClients(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;
+    }
+    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 removeUserFromConversation(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 } = (0, messageGenerator_1.generateGenericMessage)(payload, this.messageTimer);
+        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 (0, messageSender_1.sendMessage)(() => 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;
+    }
+    /**
+     *   ###############################################
+     *   ################ 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);
+        //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, fullyQualifiedClientIdUtils_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) {
+        return (0, messageSender_1.sendMessage)(async () => {
+            const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(conversationGroupId).asBytes;
+            const externalProposal = await this.mlsService.newExternalProposal(core_crypto_1.ExternalProposalType.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);
+    }
+    async wipeMLSConversation(conversationId) {
+        return this.mlsService.wipeConversation(conversationId);
+    }
+}
+exports.ConversationService = ConversationService;
+//# sourceMappingURL=ConversationService.js.map