@wireapp/core 32.0.7 → 32.1.0

package/package.json

@@ -43,13 +43,14 @@
     "jest": "29.0.3",
     "jest-babel": "1.0.1",
     "jest-jasmine2": "29.0.3",
+    "jest-websocket-mock": "2.4.0",
     "karma": "6.4.1",
     "karma-chrome-launcher": "3.1.1",
     "karma-jasmine": "4.0.2",
     "karma-jasmine-diff-reporter": "2.0.1",
     "karma-sourcemap-loader": "0.3.8",
     "karma-spec-reporter": "0.0.34",
-    "mock-socket": "9.0.3",
+    "mock-socket": "9.1.5",
     "nock": "13.1.1",
     "nyc": "15.1.0",
     "rimraf": "3.0.2",
@@ -81,6 +82,6 @@
     "test": "jest",
     "watch": "tsc ---watch"
   },
-  "version": "32.0.7",
-  "gitHead": "b8b83908d9516f9dc79e8e7591c0401618956caf"
+  "version": "32.1.0",
+  "gitHead": "33dcd430a801f27e7267f6d9d3dbaf4cd0869003"
 }

package/src/main/Account.d.ts

@@ -211,7 +211,7 @@ export declare class Account<T = any> extends EventEmitter {
          * When set will not decrypt and not store the last notification ID. This is useful if you only want to subscribe to unencrypted backend events
          */
         dryRun?: boolean;
-    }): Promise<() => void>;
+    }): () => void;
     private generateDbName;
     private generateSecretsDbName;
     private initEngine;

package/src/main/Account.js

@@ -377,7 +377,7 @@ class Account extends events_1.EventEmitter {
      * @param callbacks callbacks that will be called to handle different events
      * @returns close a function that will disconnect from the websocket
      */
-    async listen({ onEvent = () => { }, onConnectionStateChanged = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, dryRun = false, } = {}) {
+    listen({ onEvent = () => { }, onConnectionStateChanged = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, dryRun = false, } = {}) {
         if (!this.apiClient.context) {
             throw new Error('Context is not set - please login first');
         }
@@ -432,8 +432,8 @@ class Account extends events_1.EventEmitter {
         });
         const processNotificationStream = async (abortHandler) => {
             // Lock websocket in order to buffer any message that arrives while we handle the notification stream
-            onConnectionStateChanged(ConnectionState.PROCESSING_NOTIFICATIONS);
             this.apiClient.transport.ws.lock();
+            onConnectionStateChanged(ConnectionState.PROCESSING_NOTIFICATIONS);
             const results = await this.service.notification.processNotificationStream(async (notification, source, progress) => {
                 await handleNotification(notification, source);
                 onNotificationStreamProgress(progress);
@@ -443,13 +443,13 @@ class Account extends events_1.EventEmitter {
                 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
             this.logger.info(`Resuming message sending. ${(0, messageSender_1.getQueueLength)()} messages to be sent`);
             (0, messageSender_1.resumeMessageSending)();
-            onConnectionStateChanged(ConnectionState.LIVE);
         };
         this.apiClient.connect(processNotificationStream);
         return () => {

package/src/main/mls/MLSService/MLSService.d.ts

@@ -14,6 +14,7 @@ export declare class MLSService {
     addUsersToExistingConversation(groupId: Uint8Array, invitee: Invitee[]): Promise<import("@wireapp/api-client/src/conversation").PostMlsMessageResponse | null>;
     configureMLSCallbacks({ groupIdFromConversationId, ...coreCryptoCallbacks }: MLSCallbacks): void;
     getKeyPackagesPayload(qualifiedUsers: QualifiedUsers[]): Promise<Invitee[]>;
+    getEpoch(groupId: Uint8Array): Promise<number>;
     newProposal(proposalType: ProposalType, args: ProposalArgs | AddProposalArgs | RemoveProposalArgs): Promise<import("@wireapp/core-crypto").ProposalBundle>;
     newExternalProposal(externalProposalType: ExternalProposalType, args: ExternalProposalArgs | ExternalRemoveProposalArgs): Promise<Uint8Array>;
     processWelcomeMessage(welcomeMessage: Uint8Array): Promise<ConversationId>;

package/src/main/mls/MLSService/MLSService.js

@@ -112,6 +112,9 @@ class MLSService {
         }, []);
         return coreCryptoKeyPackagesPayload;
     }
+    getEpoch(groupId) {
+        return this.getCoreCryptoClient().conversationEpoch(groupId);
+    }
     async newProposal(proposalType, args) {
         return this.getCoreCryptoClient().newProposal(proposalType, args);
     }

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

@@ -62,6 +62,13 @@ export declare class NotificationService extends EventEmitter {
     private isOutdatedEvent;
     handleNotification(notification: Notification, source: PayloadBundleSource, dryRun?: boolean): AsyncGenerator<HandledEventPayload>;
     private cleanupPayloadBundle;
+    /**
+     * Will process one event
+     * @param event The backend event to process
+     * @param source The source of the event (websocket or notication stream)
+     * @param dryRun Will not try to decrypt if true
+     * @return the decrypted payload and the raw event. Returns `undefined` when the payload is a coreCrypto-only system message
+     */
     private handleEvent;
     /**
      * ## MLS only ##

package/src/main/notification/NotificationService.js

@@ -198,7 +198,9 @@ class NotificationService extends events_1.EventEmitter {
                 }
                 try {
                     const data = yield __await(this.handleEvent(event, source, dryRun));
-                    yield yield __await(Object.assign(Object.assign({}, data), { mappedEvent: data.mappedEvent ? this.cleanupPayloadBundle(data.mappedEvent) : undefined }));
+                    if (typeof data !== 'undefined') {
+                        yield yield __await(Object.assign(Object.assign({}, data), { mappedEvent: data.mappedEvent ? this.cleanupPayloadBundle(data.mappedEvent) : undefined }));
+                    }
                 }
                 catch (error) {
                     this.logger.error(`There was an error with notification ID "${notification.id}": ${error.message}`, error);
@@ -234,6 +236,13 @@ class NotificationService extends events_1.EventEmitter {
                 return payload;
         }
     }
+    /**
+     * Will process one event
+     * @param event The backend event to process
+     * @param source The source of the event (websocket or notication stream)
+     * @param dryRun Will not try to decrypt if true
+     * @return the decrypted payload and the raw event. Returns `undefined` when the payload is a coreCrypto-only system message
+     */
     async handleEvent(event, source, dryRun = false) {
         var _a, _b;
         switch (event.type) {
@@ -251,8 +260,8 @@ class NotificationService extends events_1.EventEmitter {
                 const encryptedData = bazinga64_1.Decoder.fromBase64(event.data).asBytes;
                 const groupId = await this.getGroupIdFromConversationId((_a = event.qualified_conversation) !== null && _a !== void 0 ? _a : { id: event.conversation, domain: '' });
                 const groupIdBytes = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-                // Check if the message includes proposals
                 const { proposals, commitDelay, message } = await this.mlsService.decryptMessage(groupIdBytes, encryptedData);
+                // Check if the message includes proposals
                 if (typeof commitDelay === 'number' || proposals.length > 0) {
                     // we are dealing with a proposal, add a task to process this proposal later on
                     // Those proposals are stored inside of coreCrypto and will be handled after a timeout
@@ -262,10 +271,12 @@ class NotificationService extends events_1.EventEmitter {
                         eventTime: event.time,
                     });
                     // This is not a text message, there is nothing more to do
-                    return { event };
+                    return undefined;
                 }
                 if (!message) {
-                    throw new Error(`MLS message received from ${source} was empty`);
+                    const newEpoch = await this.mlsService.getEpoch(groupIdBytes);
+                    this.logger.log(`Received commit message for group "${groupId}". New epoch is "${newEpoch}"`);
+                    return undefined;
                 }
                 const decryptedData = protocol_messaging_1.GenericMessage.decode(message);
                 /**