@wireapp/core 46.46.6-beta.10.d7a6c4c53 → 46.46.6-beta.14.f6fd03fe6

package/lib/Account.js

@@ -41,18 +41,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Account = exports.AccountLocalStorageStore = exports.EVENTS = exports.ConnectionState = void 0;
+exports.Account = exports.ConnectionState = exports.EVENTS = 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/");
@@ -67,11 +65,8 @@ 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");
@@ -79,17 +74,24 @@ 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 no notifications are being processed */
+    /** The websocket is closed and notifications stream is not being processed */
     ConnectionState["CLOSED"] = "closed";
-    /** The WebSocket is being opened or reconnected */
+    /** The websocket is being opened */
     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 new messages are processed live in real time */
+    /** The websocket is open and message will go through and notifications stream is fully processed */
     ConnectionState["LIVE"] = "live";
 })(ConnectionState || (exports.ConnectionState = ConnectionState = {}));
 const coreDefaultClient = {
@@ -97,31 +99,17 @@ 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;
@@ -129,14 +117,12 @@ 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,
-        coreCryptoConfig: { wasmFilePath: '', enabled: false },
-    }) {
+    constructor(apiClient = new api_client_1.APIClient(), options = { nbPrekeys: 100 }) {
         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);
@@ -155,7 +141,7 @@ class Account extends commons_1.TypedEventEmitter {
                     await this.persistCookie(this.storeEngine, cookie);
                 }
                 catch (error) {
-                    this.logger.error('Failed to save cookie:', error);
+                    this.logger.error(`Failed to save cookie: ${error.message}`, error);
                 }
             }
         });
@@ -173,16 +159,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
      */
-    useAPIVersion = async (min, max, allowDev) => {
+    async useAPIVersion(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);
-    };
-    enrollE2EI = async ({ displayName, handle, teamId, discoveryUrl, getOAuthToken, getAllConversations, certificateTtl = 90 * (TimeUtil_1.TimeInMillis.DAY / 1000), }) => {
+    }
+    async enrollE2EI({ displayName, handle, teamId, discoveryUrl, getOAuthToken, certificateTtl = 90 * (TimeUtil_1.TimeInMillis.DAY / 1000), }) {
         const context = this.apiClient.context;
         const domain = context?.domain ?? '';
         if (!this.currentClient) {
@@ -198,8 +184,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, getAllConversations);
-    };
+        return this.service.mls.enrollE2EI(discoveryUrl, user, this.currentClient, this.options.nbPrekeys, certificateTtl, getOAuthToken);
+    }
     get clientId() {
         return this.apiClient.validatedClientId;
     }
@@ -212,57 +198,52 @@ class Account extends commons_1.TypedEventEmitter {
      * @param registration The user's data
      * @param clientType Type of client to create (temporary or permanent)
      */
-    register = async (registration, clientType) => {
+    async register(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)
      */
-    init = async (clientType, { cookie } = {}) => {
+    async init(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...)
      */
-    login = async (loginData) => {
+    async login(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
      */
-    registerClient = async (loginData, useLegacyNotificationStream, 
+    async registerClient(loginData, clientInfo = coreDefaultClient, 
     /** will add extra manual entropy to the client's identity being created */
-    entropyData, clientInfo = coreDefaultClient) => {
+    entropyData) {
         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, useLegacyNotificationStream);
+        const client = await this.service.client.register(loginData, clientInfo, initialPreKeys);
         const clientId = client.id;
-        if (useLegacyNotificationStream) {
-            await this.service.notification.legacyInitializeNotificationStream(clientId);
-        }
+        await this.service.notification.initializeNotificationStream(clientId);
         await this.service.client.synchronizeClients(clientId);
         return client;
-    };
+    }
     getLocalClient() {
         return this.service?.client.loadClient();
     }
@@ -271,14 +252,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)
      */
-    initClient = async (client, mlsConfig) => {
+    async initClient(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.apiClient.context);
+        await this.service.proteus.initClient(this.storeEngine, 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);
@@ -291,8 +272,8 @@ class Account extends commons_1.TypedEventEmitter {
         }
         this.currentClient = client;
         return client;
-    };
-    buildCryptoClient = async (context, storeEngine, encryptedStore) => {
+    }
+    async buildCryptoClient(context, storeEngine, encryptedStore) {
         const baseConfig = {
             nbPrekeys: this.options.nbPrekeys,
             onNewPrekeys: async (prekeys) => {
@@ -301,19 +282,20 @@ class Account extends commons_1.TypedEventEmitter {
                 this.logger.debug(`Successfully uploaded '${prekeys.length}' PreKeys.`);
             },
         };
-        if (this.options.coreCryptoConfig?.enabled) {
+        const coreCryptoConfig = this.coreCryptoConfig;
+        if (coreCryptoConfig) {
             const { buildClient } = await Promise.resolve().then(() => __importStar(require('./messagingProtocols/proteus/ProteusService/CryptoClient/CoreCryptoWrapper')));
             const client = await buildClient(storeEngine, {
                 ...baseConfig,
-                generateSecretKey: (keyId, keySize) => (0, secretKeyGenerator_1.generateSecretKey)({ keyId, keySize, secretsDb: encryptedStore }),
-            }, this.options.coreCryptoConfig);
-            this.setMaxCoreCryptoLogLevel = client.setMaxLogLevel;
+                ...coreCryptoConfig,
+                generateSecretKey: keyId => (0, secretKeyGenerator_1.generateSecretKey)({ keyId, keySize: 16, secretsDb: encryptedStore }),
+            });
             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:
@@ -321,10 +303,10 @@ class Account extends commons_1.TypedEventEmitter {
      * - what is the groupId of a conversation
      * @param coreCallbacks
      */
-    configureCoreCallbacks = (coreCallbacks) => {
+    configureCoreCallbacks(coreCallbacks) {
         this.coreCallbacks = coreCallbacks;
-    };
-    initServices = async (context) => {
+    }
+    async initServices(context) {
         const encryptedStoreName = this.generateEncryptedDbName(context);
         this.encryptedDb = this.options.systemCrypto
             ? await (0, encryptedStore_1.createCustomEncryptedStore)(encryptedStoreName, this.options.systemCrypto)
@@ -340,7 +322,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);
@@ -350,7 +332,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, this.isMLSConversationRecoveryEnabled, mlsService);
+        const conversationService = new conversation_1.ConversationService(this.apiClient, proteusService, this.db, this.groupIdFromConversationId, subconversationService, 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);
@@ -374,88 +356,35 @@ 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
      */
-    logout = async (data) => {
+    async logout(clearData = false) {
         this.db?.close();
         this.encryptedDb?.close();
-        if (data?.clearAllData) {
-            await this.wipeAllData();
-        }
-        else if (data?.clearCryptoData) {
-            await this.wipeCryptoData();
+        if (clearData) {
+            await this.wipe();
         }
         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 and history of the current user
-     */
-    wipeAllData = async () => {
-        try {
-            if (this.storeEngine) {
-                await (0, identityClearer_1.deleteIdentity)(this.storeEngine, false);
-            }
-        }
-        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
+     * Will delete the identity of the current user
      */
-    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);
+    async wipe() {
+        await this.service?.proteus.wipe(this.storeEngine);
+        if (this.db) {
+            await (0, CoreDB_1.deleteDB)(this.db);
         }
-        await this.wipeCommonData();
-    };
+        await this.encryptedDb?.wipe();
+    }
     /**
      * return true if the current user has a MLS device that is initialized and ready to use
      */
@@ -469,105 +398,11 @@ 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 = async ({ useLegacy, onEvent = async () => { }, onConnectionStateChanged: onConnectionStateChangedCallBack = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, } = {}) => {
+    listen({ onEvent = () => { }, onConnectionStateChanged = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, dryRun = false, } = {}) {
         if (!this.currentClient) {
             throw new Error('Client has not been initialized - please login first');
         }
-        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 handleEvent = async (payload, source) => {
             const { event } = payload;
             switch (event?.type) {
                 case event_1.CONVERSATION_EVENT.MESSAGE_TIMER_UPDATE: {
@@ -577,290 +412,80 @@ class Account extends commons_1.TypedEventEmitter {
                     break;
                 }
             }
-            // Always forward the event to the consumer
             await onEvent(payload, 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 });
+        const handleNotification = async (notification, source) => {
             try {
-                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;
+                const messages = this.service.notification.handleNotification(notification, source, dryRun);
+                for await (const message of messages) {
+                    await handleEvent(message, source);
                 }
-                this.notificationProcessingQueue
-                    .push(() => this.decryptAckEmitNotification(notification, handleEvent, source, onNotificationStreamProgress))
-                    .catch(this.handleNotificationQueueError);
             }
             catch (error) {
-                this.logger.error(`Failed to handle notification "${notification.type}": ${error.message}`, error);
+                this.logger.error(`Failed to handle notification ID "${notification.id}": ${error.message}`, error);
             }
         };
-    };
-    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);
-            }
-            for await (const payload of payloads ?? []) {
-                await handleEvent(payload, source);
+        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);
             }
-            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) => {
+        });
+        const handleMissedNotifications = async (notificationId) => {
             if (this.hasMLSDevice) {
-                void (0, conversationRejoinQueue_1.queueConversationRejoin)('all-conversations', () => this.service.conversation.handleConversationsEpochMismatch());
+                (0, conversationRejoinQueue_1.queueConversationRejoin)('all-conversations', () => this.service.conversation.handleConversationsEpochMismatch());
             }
             return onMissedNotifications(notificationId);
         };
-    };
-    /**
-     * 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) => {
+        const processNotificationStream = async (abortHandler) => {
+            // Lock websocket in order to buffer any message that arrives while we handle the notification stream
             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.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);
+            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();
             // 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
-            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);
+            this.logger.info(`Resuming message sending. ${(0, messageSender_1.getQueueLength)()} messages to be sent`);
+            (0, messageSender_1.resumeMessageSending)();
+            (0, conversationRejoinQueue_1.resumeRejoiningMLSConversations)();
         };
-    };
-    /**
-     * 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) => {
+        this.apiClient.connect(processNotificationStream);
+        return () => {
+            this.apiClient.disconnect();
+            onConnectionStateChanged(ConnectionState.CLOSED);
+            this.apiClient.transport.ws.removeAllListeners();
+        };
+    }
+    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)}`;
-    };
-    initEngine = async (context, encryptedStore) => {
+    }
+    async initEngine(context, encryptedStore) {
         const dbName = this.generateDbName(context);
         this.logger.debug(`Initialising store with name "${dbName}"...`);
         const openDb = async () => {
@@ -881,43 +506,28 @@ 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);
     };
-    isMLSActiveForClient = async () => {
-        // Check for CoreCrypto library, it is required for MLS
-        if (!this.options.coreCryptoConfig?.enabled) {
+    async isMLSActiveForClient() {
+        // MLS service is initialized
+        const isMLSServiceInitialized = this.service?.mls !== undefined;
+        if (!isMLSServiceInitialized) {
             return false;
         }
-        // Check if the backend supports MLS trough removal keys
-        if (!(await this.apiClient.supportsMLS())) {
+        // Backend Supports MLS trough removal keys
+        const isMLSSupported = await this.apiClient.supportsMLS();
+        if (!isMLSSupported) {
             return false;
         }
-        // Check if MLS is enabled for the public via backend feature flag
-        const commonConfig = (await this.service?.team.getCommonFeatureConfig()) ?? {};
-        return commonConfig[team_1.FEATURE_KEY.MLS]?.status === team_1.FEATURE_STATUS.ENABLED;
-    };
-    isMLSConversationRecoveryEnabled = async () => {
+        // MLS is enabled for the public via feature flag
         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();
-    };
+        const isMLSForTeamEnabled = commonConfig[team_1.FEATURE_KEY.MLS]?.status === team_1.FeatureStatus.ENABLED;
+        return isMLSSupported && isMLSForTeamEnabled && isMLSServiceInitialized;
+    }
 }
 exports.Account = Account;