@wireapp/core 31.1.3 → 31.2.0

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

@@ -0,0 +1,129 @@
+/// <reference types="node" />
+import { APIClient } from '@wireapp/api-client';
+import * as Events from '@wireapp/api-client/src/event';
+import { Notification } from '@wireapp/api-client/src/notification/';
+import { CRUDEngine } from '@wireapp/store-engine';
+import { EventEmitter } from 'events';
+import { PayloadBundle, PayloadBundleSource } from '../conversation';
+import { NotificationError } from '../CoreError';
+import { CryptographyService } from '../cryptography';
+import { GenericMessage } from '@wireapp/protocol-messaging';
+import { AbortHandler } from '@wireapp/api-client/src/tcp';
+import { CommitPendingProposalsParams, LastKeyMaterialUpdateParams } from './types';
+import { MLSService } from '../mls';
+export declare type HandledEventPayload = {
+    event: Events.BackendEvent;
+    mappedEvent?: PayloadBundle;
+    decryptedData?: GenericMessage;
+    decryptionError?: {
+        code: number;
+        message: string;
+    };
+};
+declare enum TOPIC {
+    NOTIFICATION_ERROR = "NotificationService.TOPIC.NOTIFICATION_ERROR"
+}
+export declare type NotificationHandler = (notification: Notification, source: PayloadBundleSource, progress: {
+    done: number;
+    total: number;
+}) => Promise<void>;
+export interface NotificationService {
+    on(event: TOPIC.NOTIFICATION_ERROR, listener: (payload: NotificationError) => void): this;
+}
+export declare class NotificationService extends EventEmitter {
+    private readonly mlsService;
+    private readonly apiClient;
+    private readonly backend;
+    private readonly cryptographyService;
+    private readonly database;
+    private readonly logger;
+    static readonly TOPIC: typeof TOPIC;
+    constructor(apiClient: APIClient, cryptographyService: CryptographyService, mlsService: MLSService, storeEngine: CRUDEngine);
+    private getAllNotifications;
+    /** Should only be called with a completely new client. */
+    initializeNotificationStream(): Promise<string>;
+    hasHistory(): Promise<boolean>;
+    getNotificationEventList(): Promise<Events.BackendEvent[]>;
+    setLastEventDate(eventDate: Date): Promise<Date>;
+    setLastNotificationId(lastNotification: Notification): Promise<string>;
+    handleNotificationStream(notificationHandler: NotificationHandler, onMissedNotifications: (notificationId: string) => void, abortHandler: AbortHandler): Promise<void>;
+    /**
+     * Checks if an event should be ignored.
+     * An event that has a date prior to that last event that we have parsed should be ignored
+     *
+     * @param event
+     * @param source
+     * @param lastEventDate?
+     */
+    private isOutdatedEvent;
+    handleNotification(notification: Notification, source: PayloadBundleSource, dryRun?: boolean): AsyncGenerator<HandledEventPayload>;
+    private cleanupPayloadBundle;
+    private handleEvent;
+    /**
+     * ## MLS only ##
+     * If there is a matching conversationId => groupId pair in the database,
+     * we can find the groupId and return it as a string
+     *
+     * @param conversationQualifiedId
+     */
+    private getGroupIdFromConversationId;
+    /**
+     * ## 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>;
+    /**
+     * ## MLS only ##
+     * Store groupIds with last key material update dates.
+     *
+     * @param {groupId} params.groupId - groupId of the mls conversation
+     * @param {previousUpdateDate} params.previousUpdateDate - date of the previous key material update
+     */
+    storeLastKeyMaterialUpdateDate(params: LastKeyMaterialUpdateParams): Promise<void>;
+    /**
+     * ## MLS only ##
+     * Renew key material for a given groupId
+     *
+     * @param groupId groupId of the conversation
+     */
+    private renewKeyMaterial;
+    private createKeyMaterialUpdateTaskSchedulerId;
+    private scheduleTaskToRenewKeyMaterial;
+    /**
+     * ## MLS only ##
+     * Get all keying material last update dates and schedule tasks for renewal
+     * Function must only be called once, after application start
+     *
+     */
+    checkForKeyMaterialsUpdate(): Promise<void>;
+    private scheduleKeyPackagesSync;
+    private syncKeyPackages;
+    /**
+     * ## MLS only ##
+     * Get date of last key packages count query and schedule a task to sync it with backend
+     * Function must only be called once, after application start
+     *
+     */
+    checkForKeyPackagesBackendSync(): Promise<void>;
+}
+export {};

package/src/main/notification/NotificationService.js

@@ -0,0 +1,501 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationService = void 0;
+const commons_1 = require("@wireapp/commons");
+const Events = __importStar(require("@wireapp/api-client/src/event"));
+const store_engine_1 = require("@wireapp/store-engine");
+const events_1 = require("events");
+const logdown_1 = __importDefault(require("logdown"));
+const conversation_1 = require("../conversation");
+const ConversationMapper_1 = require("../conversation/ConversationMapper");
+const CoreError_1 = require("../CoreError");
+const UserMapper_1 = require("../user/UserMapper");
+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");
+const LowPrecisionTaskScheduler_1 = require("../util/LowPrecisionTaskScheduler/LowPrecisionTaskScheduler");
+const keyPackagesStatusStore_1 = require("../mls/keyPackagesStatusStore/keyPackagesStatusStore");
+const keyMaterialUpdatesStore_1 = require("../mls/keyMaterialUpdatesStore");
+var TOPIC;
+(function (TOPIC) {
+    TOPIC["NOTIFICATION_ERROR"] = "NotificationService.TOPIC.NOTIFICATION_ERROR";
+})(TOPIC || (TOPIC = {}));
+const DEFAULT_KEYING_MATERIAL_UPDATE_THRESHOLD = 1000 * 60 * 60 * 24 * 30; //30 days
+const INITIAL_NUMBER_OF_KEY_PACKAGES = 100;
+class NotificationService extends events_1.EventEmitter {
+    constructor(apiClient, cryptographyService, mlsService, storeEngine) {
+        super();
+        this.mlsService = mlsService;
+        this.logger = (0, logdown_1.default)('@wireapp/core/notification/NotificationService', {
+            logger: console,
+            markdown: false,
+        });
+        this.apiClient = apiClient;
+        this.cryptographyService = cryptographyService;
+        this.backend = new NotificationBackendRepository_1.NotificationBackendRepository(this.apiClient);
+        this.database = new NotificationDatabaseRepository_1.NotificationDatabaseRepository(storeEngine);
+    }
+    async getAllNotifications() {
+        const clientId = this.apiClient.clientId;
+        const lastNotificationId = await this.database.getLastNotificationId();
+        return this.backend.getAllNotifications(clientId, lastNotificationId);
+    }
+    /** Should only be called with a completely new client. */
+    async initializeNotificationStream() {
+        const clientId = this.apiClient.clientId;
+        await this.setLastEventDate(new Date(0));
+        const latestNotification = await this.backend.getLastNotification(clientId);
+        return this.setLastNotificationId(latestNotification);
+    }
+    async hasHistory() {
+        const notificationEvents = await this.getNotificationEventList();
+        return !!notificationEvents.length;
+    }
+    getNotificationEventList() {
+        return this.database.getNotificationEventList();
+    }
+    async setLastEventDate(eventDate) {
+        let databaseLastEventDate;
+        try {
+            databaseLastEventDate = await this.database.getLastEventDate();
+        }
+        catch (error) {
+            if (error instanceof store_engine_1.error.RecordNotFoundError ||
+                error.constructor.name === store_engine_1.error.RecordNotFoundError.name) {
+                return this.database.createLastEventDate(eventDate);
+            }
+            throw error;
+        }
+        if (databaseLastEventDate && eventDate > databaseLastEventDate) {
+            return this.database.updateLastEventDate(eventDate);
+        }
+        return databaseLastEventDate;
+    }
+    async setLastNotificationId(lastNotification) {
+        return this.database.updateLastNotificationId(lastNotification);
+    }
+    async handleNotificationStream(notificationHandler, onMissedNotifications, abortHandler) {
+        const { notifications, missedNotification } = await this.getAllNotifications();
+        if (missedNotification) {
+            onMissedNotifications(missedNotification);
+        }
+        for (const [index, notification] of notifications.entries()) {
+            if (abortHandler.isAborted()) {
+                /* Stop handling notifications if the websocket has been disconnected.
+                 * Upon reconnecting we are going to restart handling the notification stream for where we left of
+                 */
+                return;
+            }
+            await notificationHandler(notification, conversation_1.PayloadBundleSource.NOTIFICATION_STREAM, {
+                done: index + 1,
+                total: notifications.length,
+            }).catch(error => this.logger.error(error));
+        }
+    }
+    /**
+     * Checks if an event should be ignored.
+     * An event that has a date prior to that last event that we have parsed should be ignored
+     *
+     * @param event
+     * @param source
+     * @param lastEventDate?
+     */
+    isOutdatedEvent(event, source, lastEventDate) {
+        const isFromNotificationStream = source === conversation_1.PayloadBundleSource.NOTIFICATION_STREAM;
+        const shouldCheckEventDate = !!event.time && isFromNotificationStream && lastEventDate;
+        if (shouldCheckEventDate) {
+            /** This check prevents duplicated "You joined" system messages. */
+            const isOutdated = lastEventDate.getTime() >= new Date(event.time).getTime();
+            return isOutdated;
+        }
+        return false;
+    }
+    handleNotification(notification, source, dryRun = false) {
+        return __asyncGenerator(this, arguments, function* handleNotification_1() {
+            for (const event of notification.payload) {
+                this.logger.log(`Handling event of type "${event.type}" for notification with ID "${notification.id}"`, event);
+                let lastEventDate = undefined;
+                try {
+                    lastEventDate = yield __await(this.database.getLastEventDate());
+                }
+                catch (_a) { }
+                if ('time' in event && this.isOutdatedEvent(event, source, lastEventDate)) {
+                    this.logger.info(`Ignored outdated event type: '${event.type}'`);
+                    continue;
+                }
+                try {
+                    const data = yield __await(this.handleEvent(event, source, dryRun));
+                    yield yield __await(Object.assign(Object.assign({}, data), { mappedEvent: data.mappedEvent ? this.cleanupPayloadBundle(data.mappedEvent) : undefined }));
+                }
+                catch (error) {
+                    this.logger.error(`There was an error with notification ID "${notification.id}": ${error.message}`, error);
+                    const notificationError = {
+                        error: error,
+                        notification,
+                        type: CoreError_1.CoreError.NOTIFICATION_ERROR,
+                    };
+                    this.emit(NotificationService.TOPIC.NOTIFICATION_ERROR, notificationError);
+                }
+            }
+            if (!dryRun && !notification.transient) {
+                // keep track of the last handled notification for next time we fetch the notification stream
+                yield __await(this.setLastNotificationId(notification));
+            }
+        });
+    }
+    cleanupPayloadBundle(payload) {
+        switch (payload.type) {
+            case conversation_1.PayloadBundleType.ASSET: {
+                const assetContent = payload.content;
+                const isMetaData = !!(assetContent === null || assetContent === void 0 ? void 0 : assetContent.original) && !(assetContent === null || assetContent === void 0 ? void 0 : assetContent.uploaded);
+                const isAbort = !!assetContent.abortReason || (!assetContent.original && !assetContent.uploaded);
+                if (isMetaData) {
+                    payload.type = conversation_1.PayloadBundleType.ASSET_META;
+                }
+                else if (isAbort) {
+                    payload.type = conversation_1.PayloadBundleType.ASSET_ABORT;
+                }
+                return payload;
+            }
+            default:
+                return payload;
+        }
+    }
+    async handleEvent(event, source, dryRun = false) {
+        var _a, _b;
+        switch (event.type) {
+            case Events.CONVERSATION_EVENT.MLS_WELCOME_MESSAGE:
+                const data = bazinga64_1.Decoder.fromBase64(event.data).asBytes;
+                // We extract the groupId from the welcome message and let coreCrypto store this group
+                const newGroupId = await this.mlsService.processWelcomeMessage(data);
+                const groupIdStr = bazinga64_1.Encoder.toBase64(newGroupId).asString;
+                // The groupId can then be sent back to the consumer
+                return {
+                    event: Object.assign(Object.assign({}, event), { data: groupIdStr }),
+                    mappedEvent: ConversationMapper_1.ConversationMapper.mapConversationEvent(Object.assign(Object.assign({}, event), { data: groupIdStr }), source),
+                };
+            case Events.CONVERSATION_EVENT.MLS_MESSAGE_ADD:
+                const encryptedData = bazinga64_1.Decoder.fromBase64(event.data).asBytes;
+                const groupId = await this.getGroupIdFromConversationId((_a = event.qualified_conversation) !== null && _a !== void 0 ? _a : { id: event.conversation, domain: '' });
+                const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
+                // Check if the message includes proposals
+                const { proposals, commitDelay, message } = await this.mlsService.decryptMessage(groupIdBytes, encryptedData);
+                if (typeof commitDelay === 'number' || proposals.length > 0) {
+                    // we are dealing with a proposal, add a task to process this proposal later on
+                    // Those proposals are stored inside of coreCrypto and will be handled after a timeout
+                    await this.handlePendingProposals({
+                        groupId,
+                        delayInMs: commitDelay !== null && commitDelay !== void 0 ? commitDelay : 0,
+                        eventTime: event.time,
+                    });
+                    // This is not a text message, there is nothing more to do
+                    return { event };
+                }
+                if (!message) {
+                    throw new Error(`MLS message received from ${source} was empty`);
+                }
+                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
+                 */
+                return { event, decryptedData };
+            // Encrypted Proteus events
+            case Events.CONVERSATION_EVENT.OTR_MESSAGE_ADD: {
+                if (dryRun) {
+                    // In case of a dry run, we do not want to decrypt messages
+                    // We just return the raw event to the caller
+                    return { event };
+                }
+                try {
+                    const decryptedData = await this.cryptographyService.decryptMessage(event);
+                    return {
+                        mappedEvent: this.cryptographyService.mapGenericMessage(event, decryptedData, source),
+                        event,
+                        decryptedData,
+                    };
+                }
+                catch (error) {
+                    return { event, decryptionError: error };
+                }
+            }
+            // Meta events
+            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((_b = event.qualified_conversation) !== null && _b !== void 0 ? _b : { id: event.conversation, domain: '' });
+                if (!conversation) {
+                    throw new Error('no conv');
+                }
+            case Events.CONVERSATION_EVENT.MESSAGE_TIMER_UPDATE:
+            case Events.CONVERSATION_EVENT.RENAME:
+            case Events.CONVERSATION_EVENT.TYPING: {
+                const { conversation, from } = event;
+                const metaEvent = Object.assign(Object.assign({}, event), { conversation, from });
+                return { mappedEvent: ConversationMapper_1.ConversationMapper.mapConversationEvent(metaEvent, source), event };
+            }
+            // User events
+            case Events.USER_EVENT.CONNECTION:
+            case Events.USER_EVENT.CLIENT_ADD:
+            case Events.USER_EVENT.UPDATE:
+            case Events.USER_EVENT.CLIENT_REMOVE: {
+                return { mappedEvent: UserMapper_1.UserMapper.mapUserEvent(event, this.apiClient.context.userId, source), event };
+            }
+        }
+        return { event };
+    }
+    /**
+     * ## MLS only ##
+     * If there is a matching conversationId => groupId pair in the database,
+     * we can find the groupId and return it as a string
+     *
+     * @param conversationQualifiedId
+     */
+    async getGroupIdFromConversationId(conversationQualifiedId) {
+        var _a, _b;
+        const { id: conversationId, domain: conversationDomain } = conversationQualifiedId;
+        const groupId = await ((_b = (_a = this.mlsService).groupIdFromConversationId) === null || _b === void 0 ? void 0 : _b.call(_a, conversationQualifiedId));
+        if (!groupId) {
+            throw new Error(`Could not find a group_id for conversation ${conversationId}@${conversationDomain}`);
+        }
+        return groupId;
+    }
+    /**
+     * ## 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 }) {
+        try {
+            await this.mlsService.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);
+        }
+    }
+    /**
+     * ## MLS only ##
+     * Store groupIds with last key material update dates.
+     *
+     * @param {groupId} params.groupId - groupId of the mls conversation
+     * @param {previousUpdateDate} params.previousUpdateDate - date of the previous key material update
+     */
+    async storeLastKeyMaterialUpdateDate(params) {
+        keyMaterialUpdatesStore_1.keyMaterialUpdatesStore.storeLastKeyMaterialUpdateDate(params);
+        await this.scheduleTaskToRenewKeyMaterial(params);
+    }
+    /**
+     * ## MLS only ##
+     * Renew key material for a given groupId
+     *
+     * @param groupId groupId of the conversation
+     */
+    async renewKeyMaterial({ groupId }) {
+        try {
+            const groupConversationExists = await this.mlsService.conversationExists(bazinga64_1.Decoder.fromBase64(groupId).asBytes);
+            if (!groupConversationExists) {
+                keyMaterialUpdatesStore_1.keyMaterialUpdatesStore.deleteLastKeyMaterialUpdateDate({ groupId });
+                return;
+            }
+            const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
+            await this.mlsService.updateKeyingMaterial(groupIdDecodedFromBase64);
+            const keyRenewalTime = new Date().getTime();
+            const keyMaterialUpdateDate = { groupId, previousUpdateDate: keyRenewalTime };
+            await this.storeLastKeyMaterialUpdateDate(keyMaterialUpdateDate);
+        }
+        catch (error) {
+            this.logger.error(`Error while renewing key material for groupId ${groupId}`, error);
+        }
+    }
+    createKeyMaterialUpdateTaskSchedulerId(groupId) {
+        return `renew-key-material-update-${groupId}`;
+    }
+    async scheduleTaskToRenewKeyMaterial({ groupId, previousUpdateDate }) {
+        var _a;
+        //given period of time (30 days by default) after last update date renew key material
+        const keyingMaterialUpdateThreshold = ((_a = this.mlsService.config) === null || _a === void 0 ? void 0 : _a.keyingMaterialUpdateThreshold) || DEFAULT_KEYING_MATERIAL_UPDATE_THRESHOLD;
+        const firingDate = previousUpdateDate + keyingMaterialUpdateThreshold;
+        const key = this.createKeyMaterialUpdateTaskSchedulerId(groupId);
+        LowPrecisionTaskScheduler_1.LowPrecisionTaskScheduler.addTask({
+            task: () => this.renewKeyMaterial({ groupId }),
+            intervalDelay: commons_1.TimeUtil.TimeInMillis.MINUTE,
+            firingDate,
+            key,
+        });
+    }
+    /**
+     * ## MLS only ##
+     * Get all keying material last update dates and schedule tasks for renewal
+     * Function must only be called once, after application start
+     *
+     */
+    async checkForKeyMaterialsUpdate() {
+        try {
+            const keyMaterialUpdateDates = keyMaterialUpdatesStore_1.keyMaterialUpdatesStore.getAllUpdateDates();
+            keyMaterialUpdateDates.forEach(date => this.scheduleTaskToRenewKeyMaterial(date));
+        }
+        catch (error) {
+            this.logger.error('Could not get last key material update dates', error);
+        }
+    }
+    scheduleKeyPackagesSync(firingDate) {
+        TaskScheduler_1.TaskScheduler.addTask({
+            firingDate,
+            key: 'try-key-packages-backend-sync',
+            task: () => this.syncKeyPackages(),
+        });
+    }
+    async syncKeyPackages() {
+        const validKeyPackagesCount = await this.mlsService.clientValidKeypackagesCount();
+        const lastQueryDate = new Date().getTime();
+        await keyPackagesStatusStore_1.keyPackagesStatusStore.saveState({ lastQueryDate });
+        const minAllowedNumberOfKeyPackages = INITIAL_NUMBER_OF_KEY_PACKAGES / 2;
+        if (validKeyPackagesCount <= minAllowedNumberOfKeyPackages) {
+            const clientId = this.apiClient.validatedClientId;
+            //check numbers of keys on backend
+            const backendKeyPackagesCount = await this.apiClient.api.client.getMLSKeyPackageCount(clientId);
+            if (backendKeyPackagesCount <= minAllowedNumberOfKeyPackages) {
+                //upload new keys
+                const newKeyPackages = await this.mlsService.clientKeypackages(INITIAL_NUMBER_OF_KEY_PACKAGES);
+                await this.mlsService.uploadMLSKeyPackages(newKeyPackages, clientId);
+            }
+        }
+        //schedule new task after next 24h
+        const nextKeyPackagesQueryDate = lastQueryDate + commons_1.TimeUtil.TimeInMillis.DAY;
+        this.scheduleKeyPackagesSync(nextKeyPackagesQueryDate);
+    }
+    /**
+     * ## MLS only ##
+     * Get date of last key packages count query and schedule a task to sync it with backend
+     * Function must only be called once, after application start
+     *
+     */
+    async checkForKeyPackagesBackendSync() {
+        const { lastQueryDate } = keyPackagesStatusStore_1.keyPackagesStatusStore.getState();
+        //schedule a task lastKeyPackagesQueryDate + 24H
+        const nextKeyPackagesQueryDate = lastQueryDate + commons_1.TimeUtil.TimeInMillis.DAY;
+        this.scheduleKeyPackagesSync(nextKeyPackagesQueryDate);
+    }
+}
+exports.NotificationService = NotificationService;
+NotificationService.TOPIC = TOPIC;
+//# sourceMappingURL=NotificationService.js.map

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

@@ -0,0 +1 @@
+export * from './NotificationService';

package/src/main/notification/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./NotificationService"), exports);
+//# sourceMappingURL=index.js.map