@wireapp/core 29.2.2 → 29.3.0

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [29.3.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@29.2.4...@wireapp/core@29.3.0) (2022-08-25)
+
+
+### Features
+
+* periodically commit proposals (fs-690) ([#4362](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4362)) ([d821f9e](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/d821f9e43d35b4cb151588f5a7b18aa503e39410))
+
+
+
+
+
+## [29.2.4](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@29.2.3...@wireapp/core@29.2.4) (2022-08-23)
+
+**Note:** Version bump only for package @wireapp/core
+
+
+
+
+
+## [29.2.3](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@29.2.2...@wireapp/core@29.2.3) (2022-08-23)
+
+**Note:** Version bump only for package @wireapp/core
+
+
+
+
+
 ## [29.2.2](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@29.2.1...@wireapp/core@29.2.2) (2022-08-17)
 
 **Note:** Version bump only for package @wireapp/core

package/package.json

@@ -7,7 +7,7 @@
     "@otak/core-crypto": "0.3.0-es2017",
     "@types/long": "4.0.1",
     "@types/node": "~14",
-    "@wireapp/api-client": "19.21.4",
+    "@wireapp/api-client": "19.21.6",
     "@wireapp/commons": "4.3.0",
     "@wireapp/cryptobox": "12.8.0",
     "@wireapp/store-engine-dexie": "1.6.10",
@@ -77,6 +77,6 @@
     "test:node": "nyc jasmine --config=jasmine.json",
     "watch": "tsc ---watch"
   },
-  "version": "29.2.2",
-  "gitHead": "7270b4cee73a6944e1b05e5374bd2860c23d0bb7"
+  "version": "29.3.0",
+  "gitHead": "e9707c97b3cfa69fa1e51c21d0d0ca6923f57d4d"
 }

package/src/main/Account.js

@@ -137,10 +137,14 @@ class Account extends events_1.EventEmitter {
      * @param cookie The cookie to identify the user against backend (will use the browser's one if not given)
      */
     async init(clientType, cookie, initClient = true) {
+        var _a;
         const context = await this.apiClient.init(clientType, cookie);
         await this.initServices(context);
+        // Assumption: client gets only initialized once
         if (initClient) {
             await this.initClient({ clientType });
+            // initialize schedulers for pending mls proposals once client is initialized
+            await ((_a = this.service) === null || _a === void 0 ? void 0 : _a.notification.checkExistingPendingProposals());
         }
         return context;
     }

package/src/main/conversation/ConversationService/ConversationService.d.ts

@@ -4,7 +4,7 @@ import { MessageSendingStatus, Conversation, DefaultConversationRoleName, MutedS
 import type { ConversationMemberLeaveEvent } from '@wireapp/api-client/src/event';
 import type { QualifiedId, UserPreKeyBundleMap } from '@wireapp/api-client/src/user';
 import { MessageTimer } from '../../conversation/';
-import type { RemoteData } from '../../conversation/content/';
+import type { RemoteData } from '../content';
 import type { CryptographyService } from '../../cryptography/';
 import type { ClearConversationMessage, DeleteMessage, HideMessage, OtrMessage } from '../message/OtrMessage';
 import { XOR } from '@wireapp/commons/src/main/util/TypeUtil';

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

@@ -839,6 +839,9 @@ class ConversationService {
          */
         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) {
@@ -871,6 +874,8 @@ class ConversationService {
         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 coreCryptoClient = this.coreCryptoClientProvider();
         const encrypted = await coreCryptoClient.encryptMessage(groupIdBytes, protocol_messaging_1.GenericMessage.encode(genericMessage).finish());
         try {
@@ -886,7 +891,6 @@ class ConversationService {
         const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
         const coreCryptoKeyPackagesPayload = await this.getCoreCryptoKeyPackagesPayload([...qualifiedUserIds]);
         const response = await this.addUsersToExistingMLSConversation(groupIdDecodedFromBase64, coreCryptoKeyPackagesPayload);
-        console.info('addUsersToMLSGroup', conversationId, qualifiedUserIds, groupIdDecodedFromBase64, response);
         const conversation = await this.getConversations(conversationId.id);
         return {
             events: (response === null || response === void 0 ? void 0 : response.events) || [],

package/src/main/conversation/content/AssetContent.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 import type { Asset } from '@wireapp/protocol-messaging';
-import type { AbortReason, AssetTransferState } from '../../conversation/';
-import type { FileContent, FileMetaDataContent, ImageContent, LegalHoldStatus } from '../../conversation/content/';
-import type { EncryptedAssetUploaded } from '../../cryptography/';
+import type { AbortReason, AssetTransferState } from '..';
+import type { FileContent, FileMetaDataContent, ImageContent, LegalHoldStatus } from '.';
+import type { EncryptedAssetUploaded } from '../../cryptography';
 export declare type ImageMetaData = Asset.IImageMetaData;
 export declare type VideoMetaData = Asset.IVideoMetaData;
 export declare type Preview = Asset.IPreview;

package/src/main/conversation/content/ContentType.d.ts

@@ -1,6 +1,6 @@
 import type { Connection } from '@wireapp/api-client/src/connection/';
-import type { ClientActionType } from '../';
-import type { AssetContent, ClearedContent, ClientActionContent, ConfirmationContent, ConversationContent, DeletedContent, EditedTextContent, FileAssetAbortContent, FileAssetContent, FileAssetMetaDataContent, HiddenContent, ImageAssetContent, ImageContent, LocationContent, ReactionContent, TextContent } from '../content/';
+import type { ClientActionType } from '..';
+import type { AssetContent, ClearedContent, ClientActionContent, ConfirmationContent, ConversationContent, DeletedContent, EditedTextContent, FileAssetAbortContent, FileAssetContent, FileAssetMetaDataContent, HiddenContent, ImageAssetContent, ImageContent, LocationContent, ReactionContent, TextContent } from '.';
 export declare function isAbortedAssetContent(content: ConversationContent): content is AssetContent;
 export declare function isAssetContent(content: ConversationContent): content is AssetContent;
 export declare function isClearedContent(content: ConversationContent): content is ClearedContent;

package/src/main/conversation/content/ConversationContent.d.ts

@@ -1,3 +1,3 @@
-import type { ClientActionType } from '../';
-import type { AssetContent, ButtonActionContent, ButtonActionConfirmationContent, CallingContent, ClearedContent, ClientActionContent, ClientAddContent, ClientRemoveContent, CompositeContent, ConfirmationContent, ConnectionContent, DeletedContent, EditedTextContent, FileAssetAbortContent, FileAssetContent, FileAssetMetaDataContent, HiddenContent, ImageAssetContent, ImageContent, KnockContent, LocationContent, ReactionContent, TextContent } from './';
+import type { ClientActionType } from '..';
+import type { AssetContent, ButtonActionContent, ButtonActionConfirmationContent, CallingContent, ClearedContent, ClientActionContent, ClientAddContent, ClientRemoveContent, CompositeContent, ConfirmationContent, ConnectionContent, DeletedContent, EditedTextContent, FileAssetAbortContent, FileAssetContent, FileAssetMetaDataContent, HiddenContent, ImageAssetContent, ImageContent, KnockContent, LocationContent, ReactionContent, TextContent } from '.';
 export declare type ConversationContent = AssetContent | ButtonActionContent | ButtonActionConfirmationContent | CallingContent | ClearedContent | ClientActionContent | ClientActionType | ClientAddContent | ClientRemoveContent | CompositeContent | ConfirmationContent | ConnectionContent | DeletedContent | EditedTextContent | FileAssetAbortContent | FileAssetContent | FileAssetMetaDataContent | HiddenContent | ImageAssetContent | ImageContent | KnockContent | LocationContent | ReactionContent | TextContent;

package/src/main/conversation/content/EditedTextContent.d.ts

@@ -1,4 +1,4 @@
-import type { QuoteContent, TextContent } from '../content/';
+import type { QuoteContent, TextContent } from '.';
 export interface EditedTextContent extends TextContent {
     originalMessageId: string;
     /**

package/src/main/conversation/content/LinkPreviewContent.d.ts

@@ -1,5 +1,5 @@
 import type { ILinkPreview } from '@wireapp/protocol-messaging';
-import type { ImageAssetContent, ImageContent, LegalHoldStatus } from '../content/';
+import type { ImageAssetContent, ImageContent, LegalHoldStatus } from '.';
 export interface LinkPreviewContent extends Omit<ILinkPreview, 'image'> {
     expectsReadConfirmation?: boolean;
     legalHoldStatus?: LegalHoldStatus;

package/src/main/conversation/content/LocationContent.d.ts

@@ -1,4 +1,4 @@
-import type { LegalHoldStatus } from './';
+import type { LegalHoldStatus } from '.';
 export interface LocationContent {
     expectsReadConfirmation?: boolean;
     latitude: number;

package/src/main/conversation/content/QuoteContent.d.ts

@@ -1,5 +1,5 @@
 import type { IQuote } from '@wireapp/protocol-messaging';
-import type { AssetContent, LocationContent, TextContent } from '../content/';
+import type { AssetContent, LocationContent, TextContent } from '.';
 export { IQuote as QuoteContent };
 export interface QuoteMessageContent {
     content: AssetContent | LocationContent | TextContent;

package/src/main/conversation/content/ReactionContent.d.ts

@@ -1,5 +1,5 @@
 import type { LegalHoldStatus } from '.';
-import type { ReactionType } from '../';
+import type { ReactionType } from '..';
 export interface ReactionContent {
     legalHoldStatus?: LegalHoldStatus;
     originalMessageId: string;

package/src/main/conversation/content/TextContent.d.ts

@@ -1,4 +1,4 @@
-import type { LegalHoldStatus, LinkPreviewUploadedContent, MentionContent, QuoteContent } from '../content/';
+import type { LegalHoldStatus, LinkPreviewUploadedContent, MentionContent, QuoteContent } from '.';
 export interface TextContent {
     expectsReadConfirmation?: boolean;
     legalHoldStatus?: LegalHoldStatus;

package/src/main/cryptography/CryptographyDatabaseRepository.d.ts

@@ -5,7 +5,8 @@ export declare enum DatabaseStores {
     KEYS = "keys",
     PRE_KEYS = "prekeys",
     SESSIONS = "sessions",
-    GROUP_IDS = "group_ids"
+    GROUP_IDS = "group_ids",
+    PENDING_PROPOSALS = "pending_proposals"
 }
 export declare class CryptographyDatabaseRepository {
     private readonly storeEngine;

package/src/main/cryptography/CryptographyDatabaseRepository.js

@@ -27,20 +27,14 @@ var DatabaseStores;
     DatabaseStores["PRE_KEYS"] = "prekeys";
     DatabaseStores["SESSIONS"] = "sessions";
     DatabaseStores["GROUP_IDS"] = "group_ids";
+    DatabaseStores["PENDING_PROPOSALS"] = "pending_proposals";
 })(DatabaseStores = exports.DatabaseStores || (exports.DatabaseStores = {}));
 class CryptographyDatabaseRepository {
     constructor(storeEngine) {
         this.storeEngine = storeEngine;
     }
     deleteStores() {
-        return Promise.all([
-            this.storeEngine.deleteAll(CryptographyDatabaseRepository.STORES.AMPLIFY),
-            this.storeEngine.deleteAll(CryptographyDatabaseRepository.STORES.CLIENTS),
-            this.storeEngine.deleteAll(CryptographyDatabaseRepository.STORES.KEYS),
-            this.storeEngine.deleteAll(CryptographyDatabaseRepository.STORES.SESSIONS),
-            this.storeEngine.deleteAll(CryptographyDatabaseRepository.STORES.PRE_KEYS),
-            this.storeEngine.deleteAll(CryptographyDatabaseRepository.STORES.GROUP_IDS),
-        ]);
+        return Promise.all(Object.keys(CryptographyDatabaseRepository.STORES).map(store => this.storeEngine.deleteAll(store)));
     }
 }
 exports.CryptographyDatabaseRepository = CryptographyDatabaseRepository;

package/src/main/notification/NotificationDatabaseRepository.d.ts

@@ -1,11 +1,7 @@
 import type { BackendEvent } from '@wireapp/api-client/src/event';
 import type { Notification } from '@wireapp/api-client/src/notification/';
 import type { CRUDEngine } from '@wireapp/store-engine';
-declare type CompoundGroupIdParams = {
-    groupId: string;
-    conversationId: string;
-    conversationDomain: string;
-};
+import { CommonMLS, CompoundGroupIdParams, StorePendingProposalsParams } from './types';
 export declare enum DatabaseStores {
     EVENTS = "events"
 }
@@ -23,7 +19,27 @@ export declare class NotificationDatabaseRepository {
     getLastNotificationId(): Promise<string>;
     updateLastNotificationId(lastNotification: Notification): Promise<string>;
     private generateCompoundGroupIdPrimaryKey;
-    addCompoundGroupId(params: CompoundGroupIdParams): Promise<void>;
+    addCompoundGroupId(params: CompoundGroupIdParams): Promise<CompoundGroupIdParams>;
     getCompoundGroupId(params: Omit<CompoundGroupIdParams, 'groupId'>): Promise<string>;
+    /**
+     * ## MLS only ##
+     * Store groupIds with pending proposals and a delay in the DB until the proposals get committed.
+     *
+     * @param groupId groupId of the mls conversation
+     * @param firingDate date when the pending proposals should be committed
+     */
+    storePendingProposal(params: StorePendingProposalsParams): Promise<boolean>;
+    /**
+     * ## MLS only ##
+     * Delete stored entries for pending proposals that have been committed.
+     *
+     * @param groupId groupId of the mls conversation
+     */
+    deletePendingProposal({ groupId }: CommonMLS): Promise<boolean>;
+    /**
+     * ## MLS only ##
+     * Get all stored entries for pending proposals.
+     *
+     */
+    getStoredPendingProposals(): Promise<StorePendingProposalsParams[]>;
 }
-export {};

package/src/main/notification/NotificationDatabaseRepository.js

@@ -29,8 +29,7 @@ var DatabaseKeys;
     DatabaseKeys["PRIMARY_KEY_LAST_EVENT"] = "z.storage.StorageKey.EVENT.LAST_DATE";
     DatabaseKeys["PRIMARY_KEY_LAST_NOTIFICATION"] = "z.storage.StorageKey.NOTIFICATION.LAST_ID";
 })(DatabaseKeys = exports.DatabaseKeys || (exports.DatabaseKeys = {}));
-const STORE_AMPLIFY = CryptographyDatabaseRepository_1.CryptographyDatabaseRepository.STORES.AMPLIFY;
-const STORE_GROUPIDS = CryptographyDatabaseRepository_1.CryptographyDatabaseRepository.STORES.GROUP_IDS;
+const STORES = Object.assign({}, CryptographyDatabaseRepository_1.CryptographyDatabaseRepository.STORES);
 class NotificationDatabaseRepository {
     constructor(storeEngine) {
         this.storeEngine = storeEngine;
@@ -39,23 +38,27 @@ class NotificationDatabaseRepository {
         return this.storeEngine.readAll(DatabaseStores.EVENTS);
     }
     async getLastEventDate() {
-        const { value } = await this.storeEngine.read(STORE_AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_EVENT);
+        const { value } = await this.storeEngine.read(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_EVENT);
         return new Date(value);
     }
     async updateLastEventDate(eventDate) {
-        await this.storeEngine.update(STORE_AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_EVENT, { value: eventDate.toISOString() });
+        await this.storeEngine.update(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_EVENT, {
+            value: eventDate.toISOString(),
+        });
         return eventDate;
     }
     async createLastEventDate(eventDate) {
-        await this.storeEngine.create(STORE_AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_EVENT, { value: eventDate.toISOString() });
+        await this.storeEngine.create(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_EVENT, {
+            value: eventDate.toISOString(),
+        });
         return eventDate;
     }
     async getLastNotificationId() {
-        const { value } = await this.storeEngine.read(STORE_AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_NOTIFICATION);
+        const { value } = await this.storeEngine.read(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_NOTIFICATION);
         return value;
     }
     async updateLastNotificationId(lastNotification) {
-        await this.storeEngine.updateOrCreate(STORE_AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_NOTIFICATION, {
+        await this.storeEngine.updateOrCreate(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_NOTIFICATION, {
             value: lastNotification.id,
         });
         return lastNotification.id;
@@ -64,10 +67,40 @@ class NotificationDatabaseRepository {
         return `${conversationId}@${conversationDomain}`;
     }
     async addCompoundGroupId(params) {
-        await this.storeEngine.updateOrCreate(STORE_GROUPIDS, this.generateCompoundGroupIdPrimaryKey(params), params.groupId);
+        await this.storeEngine.updateOrCreate(STORES.GROUP_IDS, this.generateCompoundGroupIdPrimaryKey(params), params.groupId);
+        return params;
     }
     async getCompoundGroupId(params) {
-        return this.storeEngine.read(STORE_GROUPIDS, this.generateCompoundGroupIdPrimaryKey(params));
+        return this.storeEngine.read(STORES.GROUP_IDS, this.generateCompoundGroupIdPrimaryKey(params));
+    }
+    /**
+     * ## MLS only ##
+     * Store groupIds with pending proposals and a delay in the DB until the proposals get committed.
+     *
+     * @param groupId groupId of the mls conversation
+     * @param firingDate date when the pending proposals should be committed
+     */
+    async storePendingProposal(params) {
+        await this.storeEngine.updateOrCreate(STORES.PENDING_PROPOSALS, `${params.groupId}`, params);
+        return true;
+    }
+    /**
+     * ## MLS only ##
+     * Delete stored entries for pending proposals that have been committed.
+     *
+     * @param groupId groupId of the mls conversation
+     */
+    async deletePendingProposal({ groupId }) {
+        await this.storeEngine.delete(STORES.PENDING_PROPOSALS, `${groupId}`);
+        return true;
+    }
+    /**
+     * ## MLS only ##
+     * Get all stored entries for pending proposals.
+     *
+     */
+    async getStoredPendingProposals() {
+        return this.storeEngine.readAll(STORES.PENDING_PROPOSALS);
     }
 }
 exports.NotificationDatabaseRepository = NotificationDatabaseRepository;

package/src/main/notification/NotificationService.d.ts

@@ -12,6 +12,7 @@ import { AbortHandler } from '@wireapp/api-client/src/tcp';
 import type { CoreCrypto } from '@otak/core-crypto/platforms/web/corecrypto';
 import { QualifiedId } from '@wireapp/api-client/src/user';
 import { Conversation } from '@wireapp/api-client/src/conversation';
+import { CommitPendingProposalsParams } from './types';
 export declare type HandledEventPayload = {
     event: Events.BackendEvent;
     mappedEvent?: PayloadBundle;
@@ -61,6 +62,7 @@ export declare class NotificationService extends EventEmitter {
     private cleanupPayloadBundle;
     private handleEvent;
     /**
+     * ## MLS only ##
      * If there is a groupId in the conversation, we need to store the conversationId => groupId pair
      * in order to find the groupId when decrypting messages
      * This is a bit hacky but since mls messages do not embed the groupId we need to keep a mapping of those
@@ -69,11 +71,37 @@ export declare class NotificationService extends EventEmitter {
      */
     saveConversationGroupId(conversation: Conversation): Promise<void>;
     /**
+     * ## MLS only ##
      * If there is a matching conversationId => groupId pair in the database,
      * we can find the groupId and return it as a Uint8Array
      *
      * @param conversationQualifiedId
      */
     getUint8ArrayFromConversationGroupId(conversationQualifiedId: QualifiedId): Promise<Uint8Array>;
+    /**
+     * ## MLS only ##
+     * If there are pending proposals, we need to either process them,
+     * or save them in the database for later processing
+     *
+     * @param groupId groupId of the mls conversation
+     * @param delayInMs delay in ms before processing proposals
+     * @param eventTime time of the event that had the proposals
+     */
+    private handlePendingProposals;
+    /**
+     * ## MLS only ##
+     * Commit all pending proposals for a given groupId
+     *
+     * @param groupId groupId of the conversation
+     * @param skipDelete if true, do not delete the pending proposals from the database
+     */
+    commitPendingProposals({ groupId, skipDelete }: CommitPendingProposalsParams): Promise<void>;
+    /**
+     * ## MLS only ##
+     * Get all pending proposals from the database and schedule them
+     * Function must only be called once, after application start
+     *
+     */
+    checkExistingPendingProposals(): Promise<void>;
 }
 export {};

package/src/main/notification/NotificationService.js

@@ -65,6 +65,7 @@ const NotificationBackendRepository_1 = require("./NotificationBackendRepository
 const NotificationDatabaseRepository_1 = require("./NotificationDatabaseRepository");
 const protocol_messaging_1 = require("@wireapp/protocol-messaging");
 const bazinga64_1 = require("bazinga64");
+const TaskScheduler_1 = require("../util/TaskScheduler/TaskScheduler");
 var TOPIC;
 (function (TOPIC) {
     TOPIC["NOTIFICATION_ERROR"] = "NotificationService.TOPIC.NOTIFICATION_ERROR";
@@ -209,7 +210,7 @@ class NotificationService extends events_1.EventEmitter {
         }
     }
     async handleEvent(event, source, dryRun = false) {
-        var _a;
+        var _a, _b;
         const coreCryptoClient = this.coreCryptoClientProvider();
         if (!coreCryptoClient) {
             throw new Error('Unable to access core crypto client');
@@ -227,12 +228,20 @@ class NotificationService extends events_1.EventEmitter {
                 };
             case Events.CONVERSATION_EVENT.MLS_MESSAGE_ADD:
                 const encryptedData = bazinga64_1.Decoder.fromBase64(event.data).asBytes;
-                const groupId = await this.getUint8ArrayFromConversationGroupId(event.qualified_conversation || { id: event.conversation, domain: '' });
-                const rawData = await coreCryptoClient.decryptMessage(groupId, encryptedData);
-                if (!rawData.message) {
+                const groupId = await this.getUint8ArrayFromConversationGroupId((_a = event.qualified_conversation) !== null && _a !== void 0 ? _a : { id: event.conversation, domain: '' });
+                // Check if the message includes proposals
+                const { proposals, commitDelay, message } = await coreCryptoClient.decryptMessage(groupId, encryptedData);
+                if (proposals.length > 0) {
+                    await this.handlePendingProposals({
+                        groupId: groupId.toString(),
+                        delayInMs: commitDelay !== null && commitDelay !== void 0 ? commitDelay : 0,
+                        eventTime: event.time,
+                    });
+                }
+                if (!message) {
                     throw new Error(`MLS message received from ${source} was empty`);
                 }
-                const decryptedData = protocol_messaging_1.GenericMessage.decode(rawData.message);
+                const decryptedData = protocol_messaging_1.GenericMessage.decode(message);
                 /**
                  * @todo Find a proper solution to add mappedEvent to this return
                  * otherwise event.data will be base64 raw data of the received event
@@ -261,7 +270,7 @@ class NotificationService extends events_1.EventEmitter {
             case Events.CONVERSATION_EVENT.MEMBER_JOIN:
                 // As of today (07/07/2022) the backend sends `WELCOME` message to the user's own conversation (not the actual conversation that the welcome should be part of)
                 // So in order to map conversation Ids and groupId together, we need to first fetch the conversation and get the groupId linked to it.
-                const conversation = await this.apiClient.api.conversation.getConversation((_a = event.qualified_conversation) !== null && _a !== void 0 ? _a : { id: event.conversation, domain: '' });
+                const conversation = await this.apiClient.api.conversation.getConversation((_b = event.qualified_conversation) !== null && _b !== void 0 ? _b : { id: event.conversation, domain: '' });
                 if (!conversation) {
                     throw new Error('no conv');
                 }
@@ -284,6 +293,7 @@ class NotificationService extends events_1.EventEmitter {
         return { event };
     }
     /**
+     * ## MLS only ##
      * If there is a groupId in the conversation, we need to store the conversationId => groupId pair
      * in order to find the groupId when decrypting messages
      * This is a bit hacky but since mls messages do not embed the groupId we need to keep a mapping of those
@@ -297,6 +307,7 @@ class NotificationService extends events_1.EventEmitter {
         }
     }
     /**
+     * ## MLS only ##
      * If there is a matching conversationId => groupId pair in the database,
      * we can find the groupId and return it as a Uint8Array
      *
@@ -313,6 +324,84 @@ class NotificationService extends events_1.EventEmitter {
         }
         return bazinga64_1.Decoder.fromBase64(groupId).asBytes;
     }
+    /**
+     * ## MLS only ##
+     * If there are pending proposals, we need to either process them,
+     * or save them in the database for later processing
+     *
+     * @param groupId groupId of the mls conversation
+     * @param delayInMs delay in ms before processing proposals
+     * @param eventTime time of the event that had the proposals
+     */
+    async handlePendingProposals({ delayInMs, groupId, eventTime }) {
+        if (delayInMs > 0) {
+            const eventDate = new Date(eventTime);
+            const firingDate = eventDate.setTime(eventDate.getTime() + delayInMs);
+            try {
+                await this.database.storePendingProposal({
+                    groupId,
+                    firingDate,
+                });
+            }
+            catch (error) {
+                this.logger.error('Could not store pending proposal', error);
+            }
+            finally {
+                TaskScheduler_1.TaskScheduler.addTask({
+                    task: () => this.commitPendingProposals({ groupId }),
+                    firingDate,
+                    key: groupId,
+                });
+            }
+        }
+        else {
+            await this.commitPendingProposals({ groupId, skipDelete: true });
+        }
+    }
+    /**
+     * ## MLS only ##
+     * Commit all pending proposals for a given groupId
+     *
+     * @param groupId groupId of the conversation
+     * @param skipDelete if true, do not delete the pending proposals from the database
+     */
+    async commitPendingProposals({ groupId, skipDelete = false }) {
+        const coreCryptoClient = this.coreCryptoClientProvider();
+        if (!coreCryptoClient) {
+            throw new Error('Could not get coreCryptoClient');
+        }
+        try {
+            await coreCryptoClient.commitPendingProposals(bazinga64_1.Decoder.fromBase64(groupId).asBytes);
+            if (!skipDelete) {
+                TaskScheduler_1.TaskScheduler.cancelTask(groupId);
+                await this.database.deletePendingProposal({ groupId });
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error while committing pending proposals for groupId ${groupId}`, error);
+        }
+    }
+    /**
+     * ## MLS only ##
+     * Get all pending proposals from the database and schedule them
+     * Function must only be called once, after application start
+     *
+     */
+    async checkExistingPendingProposals() {
+        try {
+            const pendingProposals = await this.database.getStoredPendingProposals();
+            if (pendingProposals.length > 0) {
+                pendingProposals.forEach(({ groupId, firingDate }) => TaskScheduler_1.TaskScheduler.addTask({
+                    task: () => this.commitPendingProposals({ groupId }),
+                    firingDate,
+                    key: groupId,
+                }));
+            }
+        }
+        catch (error) {
+            this.logger.error('Could not get pending proposals', error);
+        }
+    }
 }
 exports.NotificationService = NotificationService;
 NotificationService.TOPIC = TOPIC;

package/src/main/notification/types.d.ts

@@ -0,0 +1,17 @@
+export declare type CommonMLS = {
+    groupId: string;
+};
+export declare type CompoundGroupIdParams = {
+    conversationId: string;
+    conversationDomain: string;
+} & CommonMLS;
+export declare type HandlePendingProposalsParams = {
+    delayInMs: number;
+    eventTime: string;
+} & CommonMLS;
+export declare type CommitPendingProposalsParams = {
+    skipDelete?: boolean;
+} & CommonMLS;
+export declare type StorePendingProposalsParams = {
+    firingDate: number;
+} & CommonMLS;

package/src/main/notification/types.js

@@ -0,0 +1,21 @@
+"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 });
+//# sourceMappingURL=types.js.map

package/src/main/util/TaskScheduler/TaskScheduler.d.ts

@@ -0,0 +1,10 @@
+declare type ScheduleTaskParams = {
+    task: () => Promise<void>;
+    firingDate: number;
+    key: string;
+};
+export declare const TaskScheduler: {
+    addTask: ({ task, firingDate, key }: ScheduleTaskParams) => void;
+    cancelTask: (key: string) => void;
+};
+export {};

package/src/main/util/TaskScheduler/TaskScheduler.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2022 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskScheduler = void 0;
+const logdown_1 = __importDefault(require("logdown"));
+const logger = (0, logdown_1.default)('@wireapp/core/util/TaskScheduler/TaskScheduler', {
+    logger: console,
+    markdown: false,
+});
+const activeTimeouts = {};
+/**
+ * Execute a task at a given time.
+ *
+ * @param task function to be executed
+ * @param firingDate execution date
+ * @param key unique key for the task
+ */
+const addTask = ({ task, firingDate, key }) => {
+    const now = new Date();
+    const execute = new Date(firingDate);
+    const delay = execute.getTime() - now.getTime();
+    if (activeTimeouts[key]) {
+        cancelTask(key);
+    }
+    const timeout = setTimeout(async () => {
+        await task();
+        delete activeTimeouts[key];
+    }, delay > 0 ? delay : 0);
+    // add the task to the list of active tasks
+    activeTimeouts[key] = timeout;
+    logger.info(`New scheduled task to be executed at "${execute}" with key "${key}"`);
+};
+/**
+ * Cancel a scheduled task early
+ *
+ * @param key unique key for the task
+ */
+const cancelTask = (key) => {
+    const timeout = activeTimeouts[key];
+    if (timeout) {
+        clearTimeout(timeout);
+        delete activeTimeouts[key];
+        logger.info(`Scheduled task with key "${key}" prematurely cleared`);
+    }
+};
+exports.TaskScheduler = {
+    addTask,
+    cancelTask,
+};
+//# sourceMappingURL=TaskScheduler.js.map