@wireapp/core 46.46.6-beta.14.f6fd03fe6 → 46.46.6-beta.28.9d3034481

package/lib/Account.js

@@ -41,16 +41,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Account = exports.ConnectionState = exports.EVENTS = void 0;
+exports.Account = exports.AccountLocalStorageStore = exports.EVENTS = exports.ConnectionState = void 0;
 const auth_1 = require("@wireapp/api-client/lib/auth");
 const client_1 = require("@wireapp/api-client/lib/client/");
 const event_1 = require("@wireapp/api-client/lib/event");
+const ConsumableNotification_1 = require("@wireapp/api-client/lib/notification/ConsumableNotification");
 const tcp_1 = require("@wireapp/api-client/lib/tcp/");
 const ReconnectingWebsocket_1 = require("@wireapp/api-client/lib/tcp/ReconnectingWebsocket");
 const team_1 = require("@wireapp/api-client/lib/team");
 const TimeUtil_1 = require("@wireapp/commons/lib/util/TimeUtil");
 const api_client_1 = require("@wireapp/api-client");
 const commons_1 = require("@wireapp/commons");
+const promise_queue_1 = require("@wireapp/promise-queue");
 const store_engine_1 = require("@wireapp/store-engine");
 const account_1 = require("./account/");
 const auth_2 = require("./auth/");
@@ -65,8 +67,11 @@ const linkPreview_1 = require("./linkPreview");
 const mls_1 = require("./messagingProtocols/mls");
 const conversationRejoinQueue_1 = require("./messagingProtocols/mls/conversationRejoinQueue");
 const E2EIdentityService_1 = require("./messagingProtocols/mls/E2EIdentityService");
+const IncomingProposalsQueue_1 = require("./messagingProtocols/mls/EventHandler/events/messageAdd/IncomingProposalsQueue");
 const proteus_1 = require("./messagingProtocols/proteus");
 const CryptoClient_1 = require("./messagingProtocols/proteus/ProteusService/CryptoClient");
+const CoreCryptoWrapper_1 = require("./messagingProtocols/proteus/ProteusService/CryptoClient/CoreCryptoWrapper");
+const identityClearer_1 = require("./messagingProtocols/proteus/ProteusService/identityClearer");
 const notification_1 = require("./notification/");
 const encryptedStore_1 = require("./secretStore/encryptedStore");
 const secretKeyGenerator_1 = require("./secretStore/secretKeyGenerator");
@@ -74,24 +79,17 @@ const self_1 = require("./self/");
 const CoreDB_1 = require("./storage/CoreDB");
 const team_2 = require("./team/");
 const user_1 = require("./user/");
+const LocalStorageStore_1 = require("./util/LocalStorageStore");
 const RecurringTaskScheduler_1 = require("./util/RecurringTaskScheduler");
-var EVENTS;
-(function (EVENTS) {
-    /**
-     * event triggered when a message from an unknown client is received.
-     * An unknown client is a client we don't yet have a session with
-     */
-    EVENTS["NEW_SESSION"] = "new_session";
-})(EVENTS || (exports.EVENTS = EVENTS = {}));
 var ConnectionState;
 (function (ConnectionState) {
-    /** The websocket is closed and notifications stream is not being processed */
+    /** The WebSocket is closed and no notifications are being processed */
     ConnectionState["CLOSED"] = "closed";
-    /** The websocket is being opened */
+    /** The WebSocket is being opened or reconnected */
     ConnectionState["CONNECTING"] = "connecting";
     /** The websocket is open but locked and notifications stream is being processed */
     ConnectionState["PROCESSING_NOTIFICATIONS"] = "processing_notifications";
-    /** The websocket is open and message will go through and notifications stream is fully processed */
+    /** The WebSocket is open and new messages are processed live in real time */
     ConnectionState["LIVE"] = "live";
 })(ConnectionState || (exports.ConnectionState = ConnectionState = {}));
 const coreDefaultClient = {
@@ -99,17 +97,31 @@ const coreDefaultClient = {
     cookieLabel: 'default',
     model: '@wireapp/core',
 };
+var EVENTS;
+(function (EVENTS) {
+    /**
+     * event triggered when a message from an unknown client is received.
+     * An unknown client is a client we don't yet have a session with
+     */
+    EVENTS["NEW_SESSION"] = "new_session";
+})(EVENTS || (exports.EVENTS = EVENTS = {}));
+exports.AccountLocalStorageStore = (0, LocalStorageStore_1.LocalStorageStore)('core_account');
 class Account extends commons_1.TypedEventEmitter {
     options;
     apiClient;
     logger;
-    coreCryptoConfig;
     /** this is the client the consumer is currently using. Will be set as soon as `initClient` is called and will be rest upon logout */
     currentClient;
     storeEngine;
     db;
     encryptedDb;
     coreCallbacks;
+    connectionState = ConnectionState.CLOSED;
+    notificationProcessingQueue = new promise_queue_1.PromiseQueue({
+        name: 'notification-processing-queue',
+        paused: true,
+    });
+    setMaxCoreCryptoLogLevel = () => undefined;
     service;
     backendFeatures;
     recurringTaskScheduler;
@@ -117,12 +129,14 @@ class Account extends commons_1.TypedEventEmitter {
      * @param apiClient The apiClient instance to use in the core (will create a new new one if undefined)
      * @param accountOptions
      */
-    constructor(apiClient = new api_client_1.APIClient(), options = { nbPrekeys: 100 }) {
+    constructor(apiClient = new api_client_1.APIClient(), options = {
+        nbPrekeys: 100,
+        coreCryptoConfig: { wasmFilePath: '', enabled: false },
+    }) {
         super();
         this.options = options;
         this.apiClient = apiClient;
         this.backendFeatures = this.apiClient.backendFeatures;
-        this.coreCryptoConfig = options.coreCryptoConfig;
         this.recurringTaskScheduler = new RecurringTaskScheduler_1.RecurringTaskScheduler({
             get: async (key) => {
                 const task = await this.db?.get('recurringTasks', key);
@@ -141,7 +155,7 @@ class Account extends commons_1.TypedEventEmitter {
                     await this.persistCookie(this.storeEngine, cookie);
                 }
                 catch (error) {
-                    this.logger.error(`Failed to save cookie: ${error.message}`, error);
+                    this.logger.error('Failed to save cookie:', error);
                 }
             }
         });
@@ -159,16 +173,16 @@ class Account extends commons_1.TypedEventEmitter {
      *   - useVersion(0, 1, true) > version 1 is used
      * @return The highest version that is both supported by client and backend
      */
-    async useAPIVersion(min, max, allowDev) {
+    useAPIVersion = async (min, max, allowDev) => {
         const features = await this.apiClient.useVersion(min, max, allowDev);
         this.backendFeatures = features;
         return features;
-    }
-    persistCookie(storeEngine, cookie) {
+    };
+    persistCookie = (storeEngine, cookie) => {
         const entity = { expiration: cookie.expiration, zuid: cookie.zuid };
         return storeEngine.updateOrCreate(auth_1.AUTH_TABLE_NAME, auth_1.AUTH_COOKIE_KEY, entity);
-    }
-    async enrollE2EI({ displayName, handle, teamId, discoveryUrl, getOAuthToken, certificateTtl = 90 * (TimeUtil_1.TimeInMillis.DAY / 1000), }) {
+    };
+    enrollE2EI = async ({ displayName, handle, teamId, discoveryUrl, getOAuthToken, getAllConversations, certificateTtl = 90 * (TimeUtil_1.TimeInMillis.DAY / 1000), }) => {
         const context = this.apiClient.context;
         const domain = context?.domain ?? '';
         if (!this.currentClient) {
@@ -184,8 +198,8 @@ class Account extends commons_1.TypedEventEmitter {
             teamId,
             id: this.userId,
         };
-        return this.service.mls.enrollE2EI(discoveryUrl, user, this.currentClient, this.options.nbPrekeys, certificateTtl, getOAuthToken);
-    }
+        return this.service.mls.enrollE2EI(discoveryUrl, user, this.currentClient, this.options.nbPrekeys, certificateTtl, getOAuthToken, getAllConversations);
+    };
     get clientId() {
         return this.apiClient.validatedClientId;
     }
@@ -198,52 +212,57 @@ class Account extends commons_1.TypedEventEmitter {
      * @param registration The user's data
      * @param clientType Type of client to create (temporary or permanent)
      */
-    async register(registration, clientType) {
+    register = async (registration, clientType) => {
         const context = await this.apiClient.register(registration, clientType);
         await this.initServices(context);
         return context;
-    }
+    };
     /**
      * Will init the core with an already logged in user
      *
      * @param clientType The type of client the user is using (temporary or permanent)
      */
-    async init(clientType, { cookie } = {}) {
+    init = async (clientType, { cookie } = {}) => {
         const context = await this.apiClient.init(clientType, cookie);
         await this.initServices(context);
         return context;
-    }
+    };
     /**
      * Will log the user in with the given credential.
      *
      * @param loginData The credentials of the user
      * @param clientInfo Info about the client to create (name, type...)
      */
-    async login(loginData) {
+    login = async (loginData) => {
         this.resetContext();
         auth_2.LoginSanitizer.removeNonPrintableCharacters(loginData);
         const context = await this.apiClient.login(loginData);
         await this.initServices(context);
         return context;
-    }
+    };
     /**
      * Will register a new client for the current user
      */
-    async registerClient(loginData, clientInfo = coreDefaultClient, 
+    registerClient = async (loginData, useLegacyNotificationStream, 
     /** will add extra manual entropy to the client's identity being created */
-    entropyData) {
+    entropyData, clientInfo = coreDefaultClient) => {
         if (!this.service || !this.apiClient.context || !this.storeEngine) {
             throw new Error('Services are not set or context not initialized.');
         }
+        if (typeof useLegacyNotificationStream !== 'boolean') {
+            throw new Error('use of legacy notifications must be explicitly set to true or false');
+        }
         // we reset the services to re-instantiate a new CryptoClient instance
         await this.initServices(this.apiClient.context);
         const initialPreKeys = await this.service.proteus.createClient(entropyData);
-        const client = await this.service.client.register(loginData, clientInfo, initialPreKeys);
+        const client = await this.service.client.register(loginData, clientInfo, initialPreKeys, useLegacyNotificationStream);
         const clientId = client.id;
-        await this.service.notification.initializeNotificationStream(clientId);
+        if (useLegacyNotificationStream) {
+            await this.service.notification.legacyInitializeNotificationStream(clientId);
+        }
         await this.service.client.synchronizeClients(clientId);
         return client;
-    }
+    };
     getLocalClient() {
         return this.service?.client.loadClient();
     }
@@ -252,14 +271,14 @@ class Account extends commons_1.TypedEventEmitter {
      *
      * @returns The local existing client or undefined if the client does not exist or is not valid (non existing on backend)
      */
-    async initClient(client, mlsConfig) {
+    initClient = async (client, mlsConfig) => {
         if (!this.service || !this.apiClient.context || !this.storeEngine) {
             throw new Error('Services are not set.');
         }
         this.apiClient.context.clientId = client.id;
         // Call /access endpoint with client_id after client initialisation
         await this.apiClient.transport.http.associateClientWithSession(client.id);
-        await this.service.proteus.initClient(this.storeEngine, this.apiClient.context);
+        await this.service.proteus.initClient(this.apiClient.context);
         if ((await this.isMLSActiveForClient()) && this.service.mls && mlsConfig) {
             const { userId, domain = '' } = this.apiClient.context;
             await this.service.mls.initClient({ id: userId, domain }, client, mlsConfig);
@@ -272,8 +291,8 @@ class Account extends commons_1.TypedEventEmitter {
         }
         this.currentClient = client;
         return client;
-    }
-    async buildCryptoClient(context, storeEngine, encryptedStore) {
+    };
+    buildCryptoClient = async (context, storeEngine, encryptedStore) => {
         const baseConfig = {
             nbPrekeys: this.options.nbPrekeys,
             onNewPrekeys: async (prekeys) => {
@@ -282,20 +301,19 @@ class Account extends commons_1.TypedEventEmitter {
                 this.logger.debug(`Successfully uploaded '${prekeys.length}' PreKeys.`);
             },
         };
-        const coreCryptoConfig = this.coreCryptoConfig;
-        if (coreCryptoConfig) {
+        if (this.options.coreCryptoConfig?.enabled) {
             const { buildClient } = await Promise.resolve().then(() => __importStar(require('./messagingProtocols/proteus/ProteusService/CryptoClient/CoreCryptoWrapper')));
             const client = await buildClient(storeEngine, {
                 ...baseConfig,
-                ...coreCryptoConfig,
-                generateSecretKey: keyId => (0, secretKeyGenerator_1.generateSecretKey)({ keyId, keySize: 16, secretsDb: encryptedStore }),
-            });
+                generateSecretKey: (keyId, keySize) => (0, secretKeyGenerator_1.generateSecretKey)({ keyId, keySize, secretsDb: encryptedStore }),
+            }, this.options.coreCryptoConfig);
+            this.setMaxCoreCryptoLogLevel = client.setMaxLogLevel;
             return [CryptoClient_1.CryptoClientType.CORE_CRYPTO, client];
         }
         const { buildClient } = await Promise.resolve().then(() => __importStar(require('./messagingProtocols/proteus/ProteusService/CryptoClient/CryptoboxWrapper')));
         const client = buildClient(storeEngine, baseConfig);
         return [CryptoClient_1.CryptoClientType.CRYPTOBOX, client];
-    }
+    };
     /**
      * In order to be able to send MLS messages, the core needs a few information from the consumer.
      * Namely:
@@ -303,10 +321,10 @@ class Account extends commons_1.TypedEventEmitter {
      * - what is the groupId of a conversation
      * @param coreCallbacks
      */
-    configureCoreCallbacks(coreCallbacks) {
+    configureCoreCallbacks = (coreCallbacks) => {
         this.coreCallbacks = coreCallbacks;
-    }
-    async initServices(context) {
+    };
+    initServices = async (context) => {
         const encryptedStoreName = this.generateEncryptedDbName(context);
         this.encryptedDb = this.options.systemCrypto
             ? await (0, encryptedStore_1.createCustomEncryptedStore)(encryptedStoreName, this.options.systemCrypto)
@@ -322,7 +340,7 @@ class Account extends commons_1.TypedEventEmitter {
         const proteusService = new proteus_1.ProteusService(this.apiClient, cryptoClient, {
             onNewClient: payload => this.emit(EVENTS.NEW_SESSION, payload),
             nbPrekeys: this.options.nbPrekeys,
-        });
+        }, this.storeEngine);
         const clientService = new client_2.ClientService(this.apiClient, proteusService, this.storeEngine);
         if (clientType === CryptoClient_1.CryptoClientType.CORE_CRYPTO && (await this.apiClient.supportsMLS())) {
             mlsService = new mls_1.MLSService(this.apiClient, cryptoClient.getNativeClient(), this.db, this.recurringTaskScheduler);
@@ -332,7 +350,7 @@ class Account extends commons_1.TypedEventEmitter {
         const giphyService = new giphy_1.GiphyService(this.apiClient);
         const linkPreviewService = new linkPreview_1.LinkPreviewService(assetService);
         const subconversationService = new SubconversationService_1.SubconversationService(this.apiClient, this.db, mlsService);
-        const conversationService = new conversation_1.ConversationService(this.apiClient, proteusService, this.db, this.groupIdFromConversationId, subconversationService, mlsService);
+        const conversationService = new conversation_1.ConversationService(this.apiClient, proteusService, this.db, this.groupIdFromConversationId, subconversationService, this.isMLSConversationRecoveryEnabled, mlsService);
         const notificationService = new notification_1.NotificationService(this.apiClient, this.storeEngine, conversationService);
         const selfService = new self_1.SelfService(this.apiClient);
         const teamService = new team_2.TeamService(this.apiClient);
@@ -356,35 +374,88 @@ class Account extends commons_1.TypedEventEmitter {
             team: teamService,
             user: userService,
         };
-    }
-    resetContext() {
+    };
+    resetContext = () => {
         this.currentClient = undefined;
         delete this.apiClient.context;
         delete this.service;
-    }
+    };
     /**
      * Will logout the current user
      * @param clearData if set to `true` will completely wipe any database that was created by the Account
      */
-    async logout(clearData = false) {
+    logout = async (data) => {
         this.db?.close();
         this.encryptedDb?.close();
-        if (clearData) {
-            await this.wipe();
+        if (data?.clearAllData) {
+            await this.wipeAllData();
+        }
+        else if (data?.clearCryptoData) {
+            await this.wipeCryptoData();
         }
         await this.apiClient.logout();
         this.resetContext();
-    }
+    };
+    wipeCommonData = async () => {
+        try {
+            await this.service?.client.deleteLocalClient();
+        }
+        catch (error) {
+            this.logger.error('Failed to delete local client during logout cleanup:', error);
+        }
+        try {
+            if (this.storeEngine) {
+                await (0, CoreCryptoWrapper_1.wipeCoreCryptoDb)(this.storeEngine);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to wipe crypto database during logout cleanup:', error);
+        }
+        try {
+            // needs to be wiped last
+            await this.encryptedDb?.wipe();
+        }
+        catch (error) {
+            this.logger.error('Failed to delete encrypted database during logout cleanup:', error);
+        }
+    };
     /**
-     * Will delete the identity of the current user
+     * Will delete the identity and history of the current user
      */
-    async wipe() {
-        await this.service?.proteus.wipe(this.storeEngine);
-        if (this.db) {
-            await (0, CoreDB_1.deleteDB)(this.db);
+    wipeAllData = async () => {
+        try {
+            if (this.storeEngine) {
+                await (0, identityClearer_1.deleteIdentity)(this.storeEngine, false);
+            }
         }
-        await this.encryptedDb?.wipe();
-    }
+        catch (error) {
+            this.logger.error('Failed to delete identity during logout cleanup:', error);
+        }
+        try {
+            if (this.db) {
+                await (0, CoreDB_1.deleteDB)(this.db);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to delete database during logout cleanup:', error);
+        }
+        await this.wipeCommonData();
+    };
+    /**
+     * Will delete the cryptography and client of the current user
+     * Will keep the history intact
+     */
+    wipeCryptoData = async () => {
+        try {
+            if (this.storeEngine) {
+                await (0, identityClearer_1.deleteIdentity)(this.storeEngine, true);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to delete identity during logout cleanup:', error);
+        }
+        await this.wipeCommonData();
+    };
     /**
      * return true if the current user has a MLS device that is initialized and ready to use
      */
@@ -398,11 +469,105 @@ class Account extends commons_1.TypedEventEmitter {
      * @param callbacks callbacks that will be called to handle different events
      * @returns close a function that will disconnect from the websocket
      */
-    listen({ onEvent = () => { }, onConnectionStateChanged = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, dryRun = false, } = {}) {
+    listen = async ({ useLegacy, onEvent = async () => { }, onConnectionStateChanged: onConnectionStateChangedCallBack = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, } = {}) => {
         if (!this.currentClient) {
             throw new Error('Client has not been initialized - please login first');
         }
-        const handleEvent = async (payload, source) => {
+        if (typeof useLegacy !== 'boolean') {
+            throw new Error('use of legacy notifications must be explicitly set to true or false');
+        }
+        const onConnectionStateChanged = this.createConnectionStateChangedHandler(onConnectionStateChangedCallBack);
+        const handleEvent = this.createEventHandler(onEvent);
+        const handleLegacyNotification = this.createLegacyNotificationHandler(handleEvent, onNotificationStreamProgress);
+        const handleNotification = this.createNotificationHandler(handleEvent, onNotificationStreamProgress, onConnectionStateChanged);
+        const handleMissedNotifications = this.createLegacyMissedNotificationsHandler(onMissedNotifications);
+        const legacyProcessNotificationStream = this.createLegacyNotificationStreamProcessor({
+            handleLegacyNotification,
+            handleMissedNotifications,
+            onConnectionStateChanged,
+        });
+        this.setupWebSocketListeners(onConnectionStateChanged, handleNotification, handleLegacyNotification, useLegacy);
+        const isClientCapableOfConsumableNotifications = this.getClientCapabilities().includes(client_1.ClientCapability.CONSUMABLE_NOTIFICATIONS);
+        const capabilities = [client_1.ClientCapability.LEGAL_HOLD_IMPLICIT_CONSENT];
+        if (!useLegacy) {
+            // let the backend now client is capable of consumable notifications
+            capabilities.push(client_1.ClientCapability.CONSUMABLE_NOTIFICATIONS);
+            this.apiClient.transport.ws.useAsyncNotificationsSocket();
+        }
+        this.logger.info(`Client is using the ${useLegacy ? 'legacy' : 'async'} notification stream`);
+        await this.service?.client.putClientCapabilities(this.currentClient.id, { capabilities });
+        /*
+         * When enabling async notifications, be aware that the backend maintains a separate queue
+         * for new async notifications (/events weboscket endpoint), which only starts populating *after* the client declares support
+         * for async notifications.
+         *
+         * Therefore, after declaring support, it's necessary to perform one final fetch from the legacy
+         * system to ensure no notifications are missed—since older notifications won't
+         * appear in the new queue.
+         *
+         * These two systems are separate, and the transition timing
+         * is important to avoid missing any messages during the switch.
+         *
+         * @todo This can be removed when all clients are capable of consumable notifications.
+         */
+        if (!isClientCapableOfConsumableNotifications && !useLegacy) {
+            // do the last legacy sync without connecting to any websockets
+            await legacyProcessNotificationStream();
+            this.logger.info('Completed final legacy notification stream processing after enabling async notifications');
+        }
+        if (useLegacy) {
+            /**
+             * immediately lock the websocket to prevent any new messages from being received
+             * before legacy notifications endpoint is fetched otherwise it'll update the last notification ID
+             * and fetching legacy notifications will return an empty list
+             */
+            this.apiClient.transport.ws.lock();
+        }
+        this.apiClient.connect(async (abortController) => {
+            // this call back is called every single time the websocket connection is (re)established
+            this.logger.info('Connection established with websocket, starting notification stream processing');
+            /**
+             * This is to avoid passing proposals too early to core crypto
+             * @See WPB-18995
+             */
+            (0, IncomingProposalsQueue_1.pauseProposalProcessing)();
+            (0, messageSender_1.pauseMessageSending)(); // pause message sending while processing notifications, it will be resumed once the processing is done and we have the marker token
+            (0, conversationRejoinQueue_1.pauseRejoiningMLSConversations)(); // We want to avoid triggering rejoins of out-of-sync MLS conversations while we are processing the notification stream
+            /**
+             * resume the notification processing queue
+             * it will start processing notifications immediately and pause if web socket connection drops
+             * we should start decryption and therefore acknowledging the notifications in order for the backend to
+             * send us the next batch of notifications, currently total size of notifications coming from web socket is limited to 500
+             * so we need to acknowledge the notifications to let the backend know we are ready for the next batch
+             */
+            this.notificationProcessingQueue.resume();
+            if (useLegacy) {
+                await legacyProcessNotificationStream(abortController);
+            }
+        });
+        return () => {
+            this.logger.info('Disconnecting from backend as requested by consumer');
+            (0, IncomingProposalsQueue_1.flushProposalsQueue)();
+            this.pauseAndFlushNotificationQueue();
+            this.apiClient.disconnect();
+            onConnectionStateChanged(ConnectionState.CLOSED);
+            this.apiClient.transport.ws.removeAllListeners();
+        };
+    };
+    createConnectionStateChangedHandler = (onConnectionStateChanged) => {
+        return (state) => {
+            this.connectionState = state;
+            onConnectionStateChanged(state);
+            this.logger.info(`Connection state changed to: ${state}`);
+        };
+    };
+    /**
+     * Creates the event handler that is invoked for each decrypted event from the backend.
+     * Responsible for handling specific event types like `MESSAGE_TIMER_UPDATE`, and then
+     * forwarding the event to the consumer via the `onEvent` callback.
+     */
+    createEventHandler = (onEvent) => {
+        return async (payload, source) => {
             const { event } = payload;
             switch (event?.type) {
                 case event_1.CONVERSATION_EVENT.MESSAGE_TIMER_UPDATE: {
@@ -412,80 +577,290 @@ class Account extends commons_1.TypedEventEmitter {
                     break;
                 }
             }
+            // Always forward the event to the consumer
             await onEvent(payload, source);
         };
-        const handleNotification = async (notification, source) => {
+    };
+    /**
+     * @deprecated This method is used to handle legacy notifications from the backend.
+     * It processes notifications from the legacy system, decrypts them, and emits events.
+     * It can be replaced with the new notification handling system using `ConsumableNotification`
+     * when all clients are capable of handling consumable notifications.
+     */
+    createLegacyNotificationHandler = (handleEvent, onNotificationStreamProgress) => {
+        return async (notification, source) => {
+            void this.notificationProcessingQueue
+                .push(async () => {
+                try {
+                    const start = Date.now();
+                    const notificationTime = this.getNotificationEventTime(notification.payload[0]);
+                    this.logger.info(`Processing legacy notification "${notification.id}" at ${notificationTime}`, {
+                        notification,
+                    });
+                    this.logger.info(`Total notifications queue length: ${this.notificationProcessingQueue.getLength()}`);
+                    this.logger.info(`Total pending proposals queue length: ${(0, IncomingProposalsQueue_1.getProposalQueueLength)()}`);
+                    if (notificationTime) {
+                        onNotificationStreamProgress(notificationTime);
+                    }
+                    const messages = this.service.notification.handleNotification(notification, source);
+                    for await (const message of messages) {
+                        await handleEvent(message, source);
+                    }
+                    this.logger.info(`Finished processing legacy notification "${notification.id}" in ${Date.now() - start}ms`);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to handle legacy notification "${notification.id}": ${error.message}`, error);
+                }
+            })
+                .catch(this.handleNotificationQueueError);
+        };
+    };
+    createNotificationHandler = (handleEvent, onNotificationStreamProgress, onConnectionStateChanged) => {
+        return async (notification, source) => {
+            this.logger.info(`Received consumable notification of type "${notification.type}"`, { notification });
             try {
-                const messages = this.service.notification.handleNotification(notification, source, dryRun);
-                for await (const message of messages) {
-                    await handleEvent(message, source);
+                if (notification.type === ConsumableNotification_1.ConsumableEvent.MISSED) {
+                    this.reactToMissedNotification();
+                    return;
+                }
+                if (notification.type === ConsumableNotification_1.ConsumableEvent.SYNCHRONIZATION) {
+                    this.notificationProcessingQueue
+                        .push(() => this.handleSynchronizationNotification(notification, onConnectionStateChanged))
+                        .catch(this.handleNotificationQueueError);
+                    return;
                 }
+                this.notificationProcessingQueue
+                    .push(() => this.decryptAckEmitNotification(notification, handleEvent, source, onNotificationStreamProgress))
+                    .catch(this.handleNotificationQueueError);
             }
             catch (error) {
-                this.logger.error(`Failed to handle notification ID "${notification.id}": ${error.message}`, error);
+                this.logger.error(`Failed to handle notification "${notification.type}": ${error.message}`, error);
             }
         };
-        this.apiClient.transport.ws.removeAllListeners(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE);
-        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE, notification => handleNotification(notification, notification_1.NotificationSource.WEBSOCKET));
-        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_STATE_CHANGE, wsState => {
-            const mapping = {
-                [ReconnectingWebsocket_1.WEBSOCKET_STATE.CLOSED]: ConnectionState.CLOSED,
-                [ReconnectingWebsocket_1.WEBSOCKET_STATE.CONNECTING]: ConnectionState.CONNECTING,
-            };
-            const connectionState = mapping[wsState];
-            if (connectionState) {
-                onConnectionStateChanged(connectionState);
+    };
+    handleNotificationQueueError = (error) => {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
+        switch (error.cause) {
+            case promise_queue_1.PromiseQueue.ERROR_CAUSES.TIMEOUT:
+                this.logger.warn('Notification decryption task timed out', error);
+                break;
+            case promise_queue_1.PromiseQueue.ERROR_CAUSES.FLUSHED:
+                this.logger.info('Notification processing queue was flushed, ignoring error', error);
+                break;
+        }
+    };
+    acknowledgeSynchronizationNotification = (notification) => {
+        this.apiClient.transport.ws.acknowledgeConsumableNotificationSynchronization(notification);
+    };
+    handleSynchronizationNotification = async (notification, onConnectionStateChanged) => {
+        this.logger.info('acknowledging synchronization notification', { notification });
+        this.acknowledgeSynchronizationNotification(notification);
+        const markerId = notification.data.marker_id;
+        const currentMarkerId = this.apiClient.transport.http.accessTokenStore.markerToken;
+        this.logger.info(`Handling synchronization notification with marker ID: ${markerId} current marker ID: ${currentMarkerId}`);
+        /**
+         * There is a chance that there might be multiple synchronization notifications (markers)
+         * in the queue in case websocket connection drops a few times
+         * Hence we only want to resume message sending and set the connection state to LIVE
+         * if the marker ID matches the current marker ID.
+         */
+        if (markerId === currentMarkerId) {
+            (0, IncomingProposalsQueue_1.resumeProposalProcessing)();
+            (0, messageSender_1.resumeMessageSending)();
+            (0, conversationRejoinQueue_1.resumeRejoiningMLSConversations)();
+            onConnectionStateChanged(ConnectionState.LIVE);
+        }
+    };
+    decryptAckEmitNotification = async (notification, handleEvent, source, onNotificationStreamProgress) => {
+        try {
+            this.logger.info(`Sending consumable notification for decryption`, notification.data.event.id);
+            const payloads = this.service.notification.handleNotification(notification.data.event, source);
+            const notificationTime = this.getNotificationEventTime(notification.data.event.payload[0]);
+            if (this.connectionState !== ConnectionState.LIVE && notificationTime) {
+                onNotificationStreamProgress(notificationTime);
             }
-        });
-        const handleMissedNotifications = async (notificationId) => {
+            for await (const payload of payloads ?? []) {
+                await handleEvent(payload, source);
+            }
+            this.logger.info(`Acknowledging consumable notification on the backend "${notification.data.delivery_tag}"`);
+            this.apiClient.transport.ws.acknowledgeNotification(notification);
+        }
+        catch (err) {
+            this.logger.error(`Failed to process notification ${notification.data.delivery_tag}`, err);
+        }
+    };
+    getNotificationEventTime = (backendEvent) => {
+        if ('time' in backendEvent && typeof backendEvent.time === 'string') {
+            return backendEvent.time;
+        }
+        return null;
+    };
+    /**
+     * Returns a function to handle missed notifications — i.e., when the backend indicates
+     * that some notifications were lost due to age (typically >28 days).
+     * Also handles MLS-specific epoch mismatch recovery by triggering a conversation rejoin.
+     *
+     * @deprecated This is used to handle legacy missed notifications.
+     * It should be replaced with the new notification handling system using `ConsumableNotification`.
+     * when all clients are capable of handling consumable notifications.
+     */
+    createLegacyMissedNotificationsHandler = (onMissedNotifications) => {
+        return async (notificationId) => {
             if (this.hasMLSDevice) {
-                (0, conversationRejoinQueue_1.queueConversationRejoin)('all-conversations', () => this.service.conversation.handleConversationsEpochMismatch());
+                void (0, conversationRejoinQueue_1.queueConversationRejoin)('all-conversations', () => this.service.conversation.handleConversationsEpochMismatch());
             }
             return onMissedNotifications(notificationId);
         };
-        const processNotificationStream = async (abortHandler) => {
-            // Lock websocket in order to buffer any message that arrives while we handle the notification stream
+    };
+    /**
+     * Returns a processor function for the notification stream (legacy sync).
+     * It pauses message sending and MLS rejoining during stream handling to prevent race conditions,
+     * then resumes normal operations after sync is complete.
+     *
+     * @deprecated This is used to do a final sync of the legacy notification stream
+     * before switching to the new notification handling system using `ConsumableNotification`.
+     * It should be replaced with the new notification handling system when all clients are capable of handling consumable notifications.
+     *
+     * @param handlers Various logic handlers wired to notification callbacks
+     */
+    createLegacyNotificationStreamProcessor = ({ handleLegacyNotification, handleMissedNotifications, onConnectionStateChanged, }) => {
+        return async (abortController) => {
             this.apiClient.transport.ws.lock();
+            (0, IncomingProposalsQueue_1.pauseProposalProcessing)();
             (0, messageSender_1.pauseMessageSending)();
-            // We want to avoid triggering rejoins of out-of-sync MLS conversations while we are processing the notification stream
             (0, conversationRejoinQueue_1.pauseRejoiningMLSConversations)();
             onConnectionStateChanged(ConnectionState.PROCESSING_NOTIFICATIONS);
-            const results = await this.service.notification.processNotificationStream(async (notification, source, progress) => {
-                await handleNotification(notification, source);
-                onNotificationStreamProgress(progress);
-            }, handleMissedNotifications, abortHandler);
-            this.logger.info('Finished processing notifications', results);
-            if (abortHandler.signal.aborted) {
-                this.logger.warn('Ending connection process as websocket was closed');
-                return;
-            }
-            onConnectionStateChanged(ConnectionState.LIVE);
-            // We can now unlock the websocket and let the new messages being handled and decrypted
-            this.apiClient.transport.ws.unlock();
+            const results = await this.service.notification.legacyProcessNotificationStream(async (notification, source) => {
+                await handleLegacyNotification(notification, source);
+            }, handleMissedNotifications, abortController);
+            this.logger.info('Finished inserting notifications for decryption from the legacy endpoint to the process queue', results);
             // We need to wait for the notification stream to be fully handled before releasing the message sending queue.
             // This is due to the nature of how message are encrypted, any change in mls epoch needs to happen before we start encrypting any kind of messages
-            this.logger.info(`Resuming message sending. ${(0, messageSender_1.getQueueLength)()} messages to be sent`);
-            (0, messageSender_1.resumeMessageSending)();
-            (0, conversationRejoinQueue_1.resumeRejoiningMLSConversations)();
-        };
-        this.apiClient.connect(processNotificationStream);
-        return () => {
-            this.apiClient.disconnect();
-            onConnectionStateChanged(ConnectionState.CLOSED);
-            this.apiClient.transport.ws.removeAllListeners();
+            void this.notificationProcessingQueue
+                .push(async () => {
+                this.logger.info(`Resuming message sending. ${(0, messageSender_1.getQueueLength)()} messages to be sent`);
+                (0, IncomingProposalsQueue_1.resumeProposalProcessing)();
+                (0, messageSender_1.resumeMessageSending)();
+                (0, conversationRejoinQueue_1.resumeRejoiningMLSConversations)();
+                onConnectionStateChanged(ConnectionState.LIVE);
+                this.apiClient.transport.ws.unlock();
+            })
+                .catch(this.handleNotificationQueueError);
         };
-    }
-    generateDbName(context) {
+    };
+    /**
+     * In case of a closed connection, we flush the notification processing queue.
+     * As we are not acknowledging them before decryption is done
+     * they will be resent next time the connection is opened
+     * this is to avoid duplicate decryption of notifications
+     */
+    pauseAndFlushNotificationQueue = () => {
+        this.notificationProcessingQueue.pause();
+        this.notificationProcessingQueue.flush();
+        this.logger.info('Notification processing queue paused and flushed');
+    };
+    pauseNotificationQueue = () => {
+        this.notificationProcessingQueue.pause();
+        this.logger.info('Notification processing queue paused');
+    };
+    resumeNotificationQueue = () => {
+        this.notificationProcessingQueue.resume();
+        this.logger.info('Notification processing queue resumed');
+    };
+    /**
+     * Sets up WebSocket event listeners for:
+     * - Incoming backend messages
+     * - WebSocket state changes
+     * On each new backend message, we pass it to the  notification handler.
+     * On state changes, we map raw socket states to public connection states and emit them.
+     */
+    setupWebSocketListeners = (onConnectionStateChanged, handleNotification, handleLegacyNotification, useLegacy) => {
+        this.logger.info('Setting up WebSocket listeners');
+        this.apiClient.transport.ws.removeAllListeners(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE);
+        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE, notification => {
+            this.logger.info('Received new notification from backend', { notification });
+            if (Account.checkIsConsumable(notification)) {
+                void handleNotification(notification, notification_1.NotificationSource.WEBSOCKET);
+                return;
+            }
+            void handleLegacyNotification(notification, notification_1.NotificationSource.WEBSOCKET);
+        });
+        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_STATE_CHANGE, wsState => {
+            const mapping = {
+                [ReconnectingWebsocket_1.WEBSOCKET_STATE.CLOSED]: ConnectionState.CLOSED,
+                [ReconnectingWebsocket_1.WEBSOCKET_STATE.CONNECTING]: ConnectionState.CONNECTING,
+            };
+            const connectionState = mapping[wsState];
+            if (connectionState === ConnectionState.CLOSED) {
+                (0, IncomingProposalsQueue_1.flushProposalsQueue)();
+                this.pauseAndFlushNotificationQueue();
+                if (useLegacy) {
+                    this.apiClient.transport.ws.lock();
+                }
+            }
+            if (connectionState) {
+                onConnectionStateChanged(connectionState);
+            }
+        });
+    };
+    /**
+     * Handles logic for reacting to a missed notification event.
+     *
+     * The backend sends a special "missed notification" signal if it detects
+     * that the client has missed one or more notifications. Once this signal is sent,
+     * the backend will **stop sending all further notifications** until the client
+     * acknowledges the missed state.
+     *
+     * Because our app currently lacks functionality to perform a full real-time sync
+     * while running, we must reload the application to re-fetch the entire state.
+     *
+     * On first detection of the missed notification:
+     * - We set a local storage flag (`has_missing_notification`) to mark that we've
+     *   entered this state.
+     * - We reload the application so the state can be re-fetched from scratch.
+     *
+     * On the next load:
+     * - If the flag is already present, we acknowledge the missed notification via
+     * the WebSocket transport, unblocking the backend so it resumes sending updates
+     * then we remove the flag.
+     */
+    reactToMissedNotification = () => {
+        this.logger.info('Reacting to missed notification from consumable async websocket');
+        const localStorageKey = 'has_missing_notification';
+        // First-time handling: set flag and reload to trigger full re-fetch of state.
+        if (!exports.AccountLocalStorageStore.has(localStorageKey)) {
+            this.logger.info('First missed notification detected, reloading to recover state');
+            exports.AccountLocalStorageStore.add(localStorageKey, 'true');
+            window.location.reload();
+            return;
+        }
+        this.logger.info('Missed notification previously detected, acknowledging to resume updates');
+        // After reload: acknowledge the missed notification so backend resumes notifications.
+        this.apiClient.transport.ws.acknowledgeMissedNotification();
+        exports.AccountLocalStorageStore.remove(localStorageKey);
+    };
+    getClientCapabilities = () => {
+        return this.currentClient?.capabilities || [];
+    };
+    static checkIsConsumable = (notification) => {
+        return 'type' in notification;
+    };
+    static checkIsLegacyNotification = (notification) => {
+        return !Account.checkIsConsumable(notification);
+    };
+    generateDbName = (context) => {
         const clientType = context.clientType === client_1.ClientType.NONE ? '' : `@${context.clientType}`;
         return `wire@${this.apiClient.config.urls.name}@${context.userId}${clientType}`;
-    }
-    generateCoreDbName(context) {
+    };
+    generateCoreDbName = (context) => {
         return `core-${this.generateDbName(context)}`;
-    }
-    generateEncryptedDbName(context) {
+    };
+    generateEncryptedDbName = (context) => {
         return `secrets-${this.generateDbName(context)}`;
-    }
-    async initEngine(context, encryptedStore) {
+    };
+    initEngine = async (context, encryptedStore) => {
         const dbName = this.generateDbName(context);
         this.logger.debug(`Initialising store with name "${dbName}"...`);
         const openDb = async () => {
@@ -506,28 +881,43 @@ class Account extends commons_1.TypedEventEmitter {
             await this.persistCookie(storeEngine, cookie);
         }
         return storeEngine;
-    }
+    };
     groupIdFromConversationId = async (conversationId, subconversationId) => {
         if (!subconversationId) {
             return this.coreCallbacks?.groupIdFromConversationId(conversationId);
         }
         return this.service?.subconversation.getSubconversationGroupId(conversationId, subconversationId);
     };
-    async isMLSActiveForClient() {
-        // MLS service is initialized
-        const isMLSServiceInitialized = this.service?.mls !== undefined;
-        if (!isMLSServiceInitialized) {
+    isMLSActiveForClient = async () => {
+        // Check for CoreCrypto library, it is required for MLS
+        if (!this.options.coreCryptoConfig?.enabled) {
             return false;
         }
-        // Backend Supports MLS trough removal keys
-        const isMLSSupported = await this.apiClient.supportsMLS();
-        if (!isMLSSupported) {
+        // Check if the backend supports MLS trough removal keys
+        if (!(await this.apiClient.supportsMLS())) {
             return false;
         }
-        // MLS is enabled for the public via feature flag
+        // Check if MLS is enabled for the public via backend feature flag
         const commonConfig = (await this.service?.team.getCommonFeatureConfig()) ?? {};
-        const isMLSForTeamEnabled = commonConfig[team_1.FEATURE_KEY.MLS]?.status === team_1.FeatureStatus.ENABLED;
-        return isMLSSupported && isMLSForTeamEnabled && isMLSServiceInitialized;
-    }
+        return commonConfig[team_1.FEATURE_KEY.MLS]?.status === team_1.FEATURE_STATUS.ENABLED;
+    };
+    isMLSConversationRecoveryEnabled = async () => {
+        const commonConfig = (await this.service?.team.getCommonFeatureConfig()) ?? {};
+        return commonConfig[team_1.FEATURE_KEY.ALLOWED_GLOBAL_OPERATIONS]?.config?.mlsConversationReset === true;
+    };
+    /**
+     * Checks the health of the WebSocket connection by sending a ping and waiting for a pong response.
+     * This is a non-disruptive check that does not close or reconnect the socket.
+     * @returns A promise that resolves to true if the socket responds with a pong within the timeout, false otherwise.
+     *
+     * @example
+     * const healthy = await account.isWebsocketHealthy();
+     * if (!healthy) {
+     *   // handle unhealthy websocket
+     * }
+     */
+    isWebsocketHealthy = async () => {
+        return this.apiClient.transport.ws.checkHealth();
+    };
 }
 exports.Account = Account;