@wireapp/core 29.2.4 → 30.0.1

package/CHANGELOG.md

@@ -3,6 +3,68 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [30.0.1](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@30.0.0...@wireapp/core@30.0.1) (2022-08-29)
+
+**Note:** Version bump only for package @wireapp/core
+
+
+
+
+
+# [30.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@29.3.0...@wireapp/core@30.0.0) (2022-08-25)
+
+
+### Features
+
+* remove user from MLS conversation (#FS-561) ([#4366](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4366)) ([89da444](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/89da4449fa3caa0cbe41fbd595326f157e7e4011)), closes [#FS-561](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/FS-561) [#4367](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4367)
+
+
+### BREAKING CHANGES
+
+* renamed removeUser function to removeUserFromProteusConversation in @wireapp/core and
+changed the types of conversation and user ids in @wireapp/bot-api MessageHandler from string to QualifiedId.
+
+* chore: initial work on remove user from mls convo
+
+* fix: use FQCI ids for client ids
+
+* fix: use FQCI ids for client ids
+
+* runfix: encode client id straight to byte array
+
+* runfix: encode client id straight to byte array
+
+* feat: send client-removal commit messages
+
+* runfix: remove event from remove user from proteus convo func
+
+* refactor: rename proteus remove func
+
+* test: add test for fully qualified ids mapping function
+
+* refactor: more precise name for remove from proteus convo
+
+* refactor: apply CR suggestions
+
+* runfix: don't convert messages twice to uint8arr
+
+* runfix: wrapp commits into uint8arr
+
+
+
+
+
+# [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

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.6",
+    "@wireapp/api-client": "20.0.1",
     "@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.4",
-  "gitHead": "c990c8b694083f507137310d328c2f29bb42afc9"
+  "version": "30.0.1",
+  "gitHead": "5cdbd6fd089dd82b5df42480a967a6044b673951"
 }

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;
     }
@@ -237,7 +241,7 @@ class Account extends events_1.EventEmitter {
         const selfService = new self_1.SelfService(this.apiClient);
         const teamService = new team_1.TeamService(this.apiClient);
         const broadcastService = new broadcast_1.BroadcastService(this.apiClient, cryptographyService);
-        const userService = new user_1.UserService(this.apiClient, broadcastService, conversationService, connectionService);
+        const userService = new user_1.UserService(this.apiClient);
         this.service = {
             account: accountService,
             asset: assetService,

package/src/main/connection/ConnectionService.d.ts

@@ -4,8 +4,7 @@ import { QualifiedId } from '@wireapp/api-client/src/user';
 export declare class ConnectionService {
     private readonly apiClient;
     constructor(apiClient: APIClient);
-    getConnections(): Promise<Connection[]>;
-    acceptConnection(userId: string): Promise<Connection>;
-    ignoreConnection(userId: string): Promise<Connection>;
+    acceptConnection(userId: QualifiedId): Promise<Connection>;
+    ignoreConnection(userId: QualifiedId): Promise<Connection>;
     createConnection(userId: QualifiedId): Promise<Connection>;
 }

package/src/main/connection/ConnectionService.js

@@ -24,9 +24,6 @@ class ConnectionService {
     constructor(apiClient) {
         this.apiClient = apiClient;
     }
-    getConnections() {
-        return this.apiClient.api.connection.getAllConnections();
-    }
     acceptConnection(userId) {
         return this.apiClient.api.connection.putConnection(userId, {
             status: connection_1.ConnectionStatus.ACCEPTED,
@@ -38,7 +35,7 @@ class ConnectionService {
         });
     }
     createConnection(userId) {
-        return this.apiClient.api.connection.postConnection(userId, '');
+        return this.apiClient.api.connection.postConnection(userId);
     }
 }
 exports.ConnectionService = ConnectionService;

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

@@ -3,8 +3,8 @@ import type { APIClient } from '@wireapp/api-client';
 import { MessageSendingStatus, Conversation, DefaultConversationRoleName, MutedStatus, NewConversation, QualifiedUserClients, UserClients, ClientMismatch } from '@wireapp/api-client/src/conversation';
 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 { MessageTimer, RemoveUsersParams } from '../../conversation/';
+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';
@@ -102,7 +102,11 @@ export declare class ConversationService {
     getAllParticipantsClients(conversationId: string, conversationDomain?: string): Promise<UserClients | QualifiedUserClients>;
     deleteMessageLocal(conversationId: string, messageIdToHide: string, sendAsProtobuf?: boolean, conversationDomain?: string): Promise<HideMessage>;
     deleteMessageEveryone(conversationId: string, messageIdToDelete: string, userIds?: string[] | QualifiedId[] | UserClients | QualifiedUserClients, sendAsProtobuf?: boolean, conversationDomain?: string, callbacks?: MessageSendingCallbacks): Promise<DeleteMessage>;
-    leaveConversation(conversationId: string): Promise<ConversationMemberLeaveEvent>;
+    leaveConversation(conversationId: QualifiedId): Promise<ConversationMemberLeaveEvent>;
+    leaveMLSConversation(conversationId: QualifiedId): Promise<ConversationMemberLeaveEvent>;
+    /**
+     * @depricated seems not to be used and is outdated. use leaveConversation instead
+     */
     leaveConversations(conversationIds?: string[]): Promise<ConversationMemberLeaveEvent[]>;
     /**
      * Create a group conversation.
@@ -127,7 +131,7 @@ export declare class ConversationService {
     getAsset({ assetId, assetToken, otrKey, sha256 }: RemoteData): Promise<Uint8Array>;
     getUnencryptedAsset(assetId: string, assetToken?: string): Promise<ArrayBuffer>;
     addUsersToProteusConversation({ conversationId, qualifiedUserIds }: Omit<AddUsersParams, 'groupId'>): Promise<import("@wireapp/api-client/src/event").ConversationMemberJoinEvent>;
-    removeUser(conversationId: string, userId: string): Promise<string>;
+    removeUserFromProteusConversation(conversationId: QualifiedId, userId: QualifiedId): Promise<ConversationMemberLeaveEvent>;
     private sendProteusMessage;
     /**
      * Sends a message to a conversation
@@ -151,4 +155,6 @@ export declare class ConversationService {
     createMLSConversation(conversationData: NewConversation): Promise<MLSReturnType>;
     private sendMLSMessage;
     addUsersToMLSConversation({ qualifiedUserIds, groupId, conversationId, }: Required<AddUsersParams>): Promise<MLSReturnType>;
+    private sendCommitBundleRemovalMessages;
+    removeUsersFromMLSConversation({ groupId, conversationId, qualifiedUserIds, }: RemoveUsersParams): Promise<MLSReturnType>;
 }

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

@@ -30,6 +30,12 @@ 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");
+//@todo: this function is temporary, we wait for the update from core-crypto side
+//they are returning regular array instead of Uint8Array for commit and welcome messages
+const optionalToUint8Array = (array) => {
+    return Array.isArray(array) ? Uint8Array.from(array) : array;
+};
 class ConversationService {
     constructor(apiClient, cryptographyService, config, coreCryptoClientProvider, notificationService) {
         this.apiClient = apiClient;
@@ -598,8 +604,20 @@ class ConversationService {
         };
     }
     leaveConversation(conversationId) {
-        return this.apiClient.api.conversation.deleteMember(conversationId, this.apiClient.context.userId);
+        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();
@@ -607,7 +625,7 @@ class ConversationService {
                 .filter(conversation => conversation.type === conversation_1.CONVERSATION_TYPE.REGULAR)
                 .map(conversation => conversation.id);
         }
-        return Promise.all(conversationIds.map(conversationId => this.leaveConversation(conversationId)));
+        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;
@@ -647,12 +665,10 @@ class ConversationService {
         return (await request.response).buffer;
     }
     async addUsersToProteusConversation({ conversationId, qualifiedUserIds }) {
-        const response = await this.apiClient.api.conversation.postMembers(conversationId, qualifiedUserIds);
-        return response;
+        return this.apiClient.api.conversation.postMembers(conversationId, qualifiedUserIds);
     }
-    async removeUser(conversationId, userId) {
-        await this.apiClient.api.conversation.deleteMember(conversationId, userId);
-        return userId;
+    async removeUserFromProteusConversation(conversationId, userId) {
+        return this.apiClient.api.conversation.deleteMember(conversationId, userId);
     }
     async sendProteusMessage(params, genericMessage, content) {
         var _a;
@@ -822,10 +838,13 @@ class ConversationService {
         const coreCryptoClient = this.coreCryptoClientProvider();
         const memberAddedMessages = await coreCryptoClient.addClientsToConversation(groupIdDecodedFromBase64, invitee);
         if (memberAddedMessages === null || memberAddedMessages === void 0 ? void 0 : memberAddedMessages.welcome) {
-            await this.apiClient.api.conversation.postMlsWelcomeMessage(Uint8Array.from(memberAddedMessages.welcome));
+            //@todo: it's temporary - we wait for core-crypto fix to return the actual Uint8Array instead of regular array
+            await this.apiClient.api.conversation.postMlsWelcomeMessage(optionalToUint8Array(memberAddedMessages.welcome));
         }
         if (memberAddedMessages === null || memberAddedMessages === void 0 ? void 0 : memberAddedMessages.commit) {
-            const messageResponse = await this.apiClient.api.conversation.postMlsMessage(Uint8Array.from(memberAddedMessages.commit));
+            const messageResponse = 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
+            optionalToUint8Array(memberAddedMessages.commit));
             await coreCryptoClient.commitAccepted(groupIdDecodedFromBase64);
             return messageResponse;
         }
@@ -839,6 +858,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 +893,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,13 +910,40 @@ 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) || [],
             conversation,
         };
     }
+    async sendCommitBundleRemovalMessages(groupIdDecodedFromBase64, commitBundle) {
+        const coreCryptoClient = this.coreCryptoClientProvider();
+        if (commitBundle === null || commitBundle === void 0 ? void 0 : commitBundle.welcome) {
+            //@todo: it's temporary - we wait for core-crypto fix to return the actual Uint8Array instead of regular array
+            await this.apiClient.api.conversation.postMlsWelcomeMessage(optionalToUint8Array(commitBundle.welcome));
+        }
+        if (commitBundle === null || commitBundle === void 0 ? void 0 : commitBundle.commit) {
+            const messageResponse = 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
+            optionalToUint8Array(commitBundle.commit));
+            await coreCryptoClient.commitAccepted(groupIdDecodedFromBase64);
+            return messageResponse;
+        }
+        return null;
+    }
+    async removeUsersFromMLSConversation({ groupId, conversationId, qualifiedUserIds, }) {
+        const coreCryptoClient = this.coreCryptoClientProvider();
+        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 commitBundle = await coreCryptoClient.removeClientsFromConversation(groupIdDecodedFromBase64, fullyQualifiedClientIds);
+        const messageResponse = await this.sendCommitBundleRemovalMessages(groupIdDecodedFromBase64, commitBundle);
+        const conversation = await this.getConversations(conversationId.id);
+        return {
+            events: (messageResponse === null || messageResponse === void 0 ? void 0 : messageResponse.events) || [],
+            conversation,
+        };
+    }
 }
 exports.ConversationService = ConversationService;
 //# sourceMappingURL=ConversationService.js.map

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

@@ -97,6 +97,11 @@ export declare type AddUsersParams = {
     qualifiedUserIds: QualifiedId[];
     groupId?: string;
 };
+export declare type RemoveUsersParams = {
+    conversationId: QualifiedId;
+    qualifiedUserIds: QualifiedId[];
+    groupId: string;
+};
 export declare type MLSReturnType = {
     events: MlsEvent[];
     conversation: Conversation;

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/user/UserService.d.ts

@@ -1,25 +1,8 @@
 import type { APIClient } from '@wireapp/api-client';
 import type { QualifiedId, User } from '@wireapp/api-client/src/user/';
-import type { AvailabilityType, BroadcastService } from '../broadcast/';
-import { ConnectionService } from '../connection';
-import { ConversationService } from '../conversation';
 export declare class UserService {
     private readonly apiClient;
-    private readonly broadcastService;
-    private readonly connectionService;
-    private readonly conversationService;
-    constructor(apiClient: APIClient, broadcastService: BroadcastService, conversationService: ConversationService, connectionService: ConnectionService);
+    constructor(apiClient: APIClient);
     getUser(userId: string | QualifiedId): Promise<User>;
     getUsers(userIds: string[] | QualifiedId[]): Promise<User[]>;
-    /**
-     * Sends a availability update to members of the same team
-     * @param teamId
-     * @param type
-     * @param options.sendAll=false will broadcast the message to all the members of the team (instead of just direct connections). Should be avoided in a big team
-     * @param options.sendAsProtobuf=false
-     */
-    setAvailability(teamId: string, type: AvailabilityType, { sendAll, sendAsProtobuf }?: {
-        sendAll?: boolean | undefined;
-        sendAsProtobuf?: boolean | undefined;
-    }): Promise<void>;
 }

package/src/main/user/UserService.js

@@ -17,21 +17,12 @@
  * 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.UserService = void 0;
-const protocol_messaging_1 = require("@wireapp/protocol-messaging");
-const uuidjs_1 = __importDefault(require("uuidjs"));
 const TypePredicateUtil_1 = require("../util/TypePredicateUtil");
-const connection_1 = require("@wireapp/api-client/src/connection");
 class UserService {
-    constructor(apiClient, broadcastService, conversationService, connectionService) {
+    constructor(apiClient) {
         this.apiClient = apiClient;
-        this.broadcastService = broadcastService;
-        this.connectionService = connectionService;
-        this.conversationService = conversationService;
     }
     getUser(userId) {
         return this.apiClient.api.user.getUser(userId);
@@ -44,38 +35,6 @@ class UserService {
             ? this.apiClient.api.user.postListUsers({ qualified_ids: userIds })
             : this.apiClient.api.user.getUsers({ ids: userIds });
     }
-    /**
-     * Sends a availability update to members of the same team
-     * @param teamId
-     * @param type
-     * @param options.sendAll=false will broadcast the message to all the members of the team (instead of just direct connections). Should be avoided in a big team
-     * @param options.sendAsProtobuf=false
-     */
-    async setAvailability(teamId, type, { sendAll = false, sendAsProtobuf = false } = {}) {
-        // Get pre-key bundles for members of your own team
-        const preKeyBundlesFromTeam = await this.broadcastService.getPreKeyBundlesFromTeam(teamId, false, !sendAll);
-        // Get pre-key bundles for all of your other 1:1 connections
-        const connections = await this.connectionService.getConnections();
-        const acceptedConnections = connections.filter(connection => connection.status === connection_1.ConnectionStatus.ACCEPTED);
-        const preKeyBundlePromises = acceptedConnections.map(connection => {
-            const mappedConnection = {
-                userId: connection.to,
-                conversationId: connection.conversation,
-            };
-            return this.conversationService.getPreKeyBundleMap(mappedConnection.conversationId, [mappedConnection.userId]);
-        });
-        const preKeyBundlesFromConnections = await Promise.all(preKeyBundlePromises);
-        // Merge pre-key bundles
-        const allPreKeyBundles = preKeyBundlesFromConnections.reduce((accumulator, preKeyBundleMap) => {
-            return Object.assign(Object.assign({}, accumulator), preKeyBundleMap);
-        }, preKeyBundlesFromTeam);
-        const genericMessage = protocol_messaging_1.GenericMessage.create({
-            availability: new protocol_messaging_1.Availability({ type }),
-            messageId: uuidjs_1.default.genV4().toString(),
-        });
-        // Broadcast availability status to your team members & external 1:1 connections
-        await this.broadcastService.broadcastGenericMessage(genericMessage, allPreKeyBundles, sendAsProtobuf);
-    }
 }
 exports.UserService = UserService;
 //# sourceMappingURL=UserService.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

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

@@ -0,0 +1,8 @@
+import { QualifiedUserClientMap } from '@wireapp/api-client/src/client';
+declare type UserId = string;
+declare type ClientId = string;
+declare type Domain = string;
+export declare type ClientIdStringType = `${UserId}:${ClientId}@${Domain}`;
+export declare const constructFullyQualifiedClientId: (userId: UserId, clientId: ClientId, domain: Domain) => ClientIdStringType;
+export declare const mapQualifiedUserClientIdsToFullyQualifiedClientIds: (qualifiedUserMap: QualifiedUserClientMap) => Uint8Array[];
+export {};

package/src/main/util/mapQualifiedUserClientIdsToFullyQualifiedClientIds.js

@@ -0,0 +1,32 @@
+"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.mapQualifiedUserClientIdsToFullyQualifiedClientIds = exports.constructFullyQualifiedClientId = void 0;
+const constructFullyQualifiedClientId = (userId, clientId, domain) => `${userId}:${clientId}@${domain}`;
+exports.constructFullyQualifiedClientId = constructFullyQualifiedClientId;
+const mapQualifiedUserClientIdsToFullyQualifiedClientIds = (qualifiedUserMap) => {
+    const encoder = new TextEncoder();
+    return Object.entries(qualifiedUserMap).flatMap(([domain, users]) => {
+        const clients = Object.entries(users);
+        return clients.flatMap(([userId, clients]) => clients.map(client => encoder.encode((0, exports.constructFullyQualifiedClientId)(userId, client.id, domain))));
+    });
+};
+exports.mapQualifiedUserClientIdsToFullyQualifiedClientIds = mapQualifiedUserClientIdsToFullyQualifiedClientIds;
+//# sourceMappingURL=mapQualifiedUserClientIdsToFullyQualifiedClientIds.js.map