@wireapp/core 38.8.2 → 38.9.0

package/lib/conversation/ConversationService/ConversationService.js

@@ -234,7 +234,7 @@ class ConversationService {
         return {
             id: payload.messageId,
             sentAt,
-            state: sentAt ? conversation_2.MessageSendingState.OUTGOING_SENT : conversation_2.MessageSendingState.CANCELLED,
+            state: sentAt ? conversation_2.MessageSendingState.OUTGOING_SENT : conversation_2.MessageSendingState.CANCELED,
         };
     }
     async addUsersToMLSConversation({ qualifiedUserIds, groupId, conversationId, }) {

package/lib/conversation/ConversationService/ConversationService.types.d.ts

@@ -91,5 +91,7 @@ export type SendResult = {
     sentAt: string;
     /** The sending state of the payload (has the payload been succesfully sent or canceled) */
     state: MessageSendingState;
+    /** In case the message was sent to some federated backend, if the backend was down at the moment of sending the `failedToSend` property will contain all the users/devices that couldn't get the message */
+    failedToSend?: QualifiedUserClients;
 };
 //# sourceMappingURL=ConversationService.types.d.ts.map

package/lib/conversation/ConversationService/ConversationService.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConversationService.types.d.ts","sourceRoot":"","sources":["../../../src/conversation/ConversationService/ConversationService.types.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,WAAW,EACX,YAAY,EACb,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAC,QAAQ,EAAC,MAAM,wDAAwD,CAAC;AAChF,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AAEzD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAE3D,OAAO,EAAC,mBAAmB,EAAC,MAAM,IAAI,CAAC;AAEvC,oBAAY,iBAAiB;IAC3B,IAAI,IAAA;IACJ,KAAK,IAAA;IACL,aAAa,IAAA;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,GAAG,WAAW,GAAG,oBAAoB,CAAC;IAExE;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,gBAAgB,CAAC,EAAE,uBAAuB,CAAC,kBAAkB,CAAC,CAAC;IAE/D;;;;;OAKG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,CACjB,MAAM,EAAE,cAAc,GAAG,oBAAoB,EAC7C,OAAO,EAAE,OAAO,KACb,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACxC;AAED;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,oBAAoB,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,OAAO,EAAE,cAAc,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG;IACpD;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,oBAAoB,CAAC,GAAG,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AAE9D,MAAM,MAAM,cAAc,GAAG;IAC3B,cAAc,EAAE,WAAW,CAAC;IAC5B,gBAAgB,EAAE,WAAW,EAAE,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,WAAW,CAAC;IAC5B,gBAAgB,EAAE,WAAW,EAAE,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAAC,MAAM,EAAE,QAAQ,EAAE,CAAC;IAAC,YAAY,EAAE,YAAY,CAAA;CAAC,CAAC;AAE7E,MAAM,MAAM,UAAU,GAAG;IACvB,iCAAiC;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,2FAA2F;IAC3F,KAAK,EAAE,mBAAmB,CAAC;CAC5B,CAAC"}
+{"version":3,"file":"ConversationService.types.d.ts","sourceRoot":"","sources":["../../../src/conversation/ConversationService/ConversationService.types.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,WAAW,EACX,YAAY,EACb,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAC,QAAQ,EAAC,MAAM,wDAAwD,CAAC;AAChF,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AAEzD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAE3D,OAAO,EAAC,mBAAmB,EAAC,MAAM,IAAI,CAAC;AAEvC,oBAAY,iBAAiB;IAC3B,IAAI,IAAA;IACJ,KAAK,IAAA;IACL,aAAa,IAAA;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,GAAG,WAAW,GAAG,oBAAoB,CAAC;IAExE;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,gBAAgB,CAAC,EAAE,uBAAuB,CAAC,kBAAkB,CAAC,CAAC;IAE/D;;;;;OAKG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,CACjB,MAAM,EAAE,cAAc,GAAG,oBAAoB,EAC7C,OAAO,EAAE,OAAO,KACb,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACxC;AAED;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,oBAAoB,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,OAAO,EAAE,cAAc,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG;IACpD;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,oBAAoB,CAAC,GAAG,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AAE9D,MAAM,MAAM,cAAc,GAAG;IAC3B,cAAc,EAAE,WAAW,CAAC;IAC5B,gBAAgB,EAAE,WAAW,EAAE,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,WAAW,CAAC;IAC5B,gBAAgB,EAAE,WAAW,EAAE,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAAC,MAAM,EAAE,QAAQ,EAAE,CAAC;IAAC,YAAY,EAAE,YAAY,CAAA;CAAC,CAAC;AAE7E,MAAM,MAAM,UAAU,GAAG;IACvB,iCAAiC;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,2FAA2F;IAC3F,KAAK,EAAE,mBAAmB,CAAC;IAC3B,4MAA4M;IAC5M,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC,CAAC"}

package/lib/conversation/message/Message.types.d.ts

@@ -1,7 +1,6 @@
 export declare enum MessageSendingState {
     INCOMING = "INCOMING",
     OUTGOING_SENT = "OUTGOING_SENT",
-    OUTGOING_UNSENT = "OUTGOING_UNSENT",
-    CANCELLED = "CANCELLED"
+    CANCELED = "CANCELED"
 }
 //# sourceMappingURL=Message.types.d.ts.map

package/lib/conversation/message/Message.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Message.types.d.ts","sourceRoot":"","sources":["../../../src/conversation/message/Message.types.ts"],"names":[],"mappings":"AAmBA,oBAAY,mBAAmB;IAC7B,QAAQ,aAAa;IACrB,aAAa,kBAAkB;IAC/B,eAAe,oBAAoB;IACnC,SAAS,cAAc;CACxB"}
+{"version":3,"file":"Message.types.d.ts","sourceRoot":"","sources":["../../../src/conversation/message/Message.types.ts"],"names":[],"mappings":"AAmBA,oBAAY,mBAAmB;IAC7B,QAAQ,aAAa;IACrB,aAAa,kBAAkB;IAC/B,QAAQ,aAAa;CACtB"}

package/lib/conversation/message/Message.types.js

@@ -23,6 +23,5 @@ var MessageSendingState;
 (function (MessageSendingState) {
     MessageSendingState["INCOMING"] = "INCOMING";
     MessageSendingState["OUTGOING_SENT"] = "OUTGOING_SENT";
-    MessageSendingState["OUTGOING_UNSENT"] = "OUTGOING_UNSENT";
-    MessageSendingState["CANCELLED"] = "CANCELLED";
+    MessageSendingState["CANCELED"] = "CANCELED";
 })(MessageSendingState = exports.MessageSendingState || (exports.MessageSendingState = {}));

package/lib/conversation/message/MessageService.d.ts

@@ -25,7 +25,7 @@ export declare class MessageService {
         nativePush?: boolean;
         onClientMismatch?: (mismatch: ClientMismatch) => void | boolean | Promise<boolean>;
     }): Promise<ClientMismatch & {
-        errored?: boolean;
+        canceled?: boolean;
     }>;
     /**
      * Sends a message to a federated backend.
@@ -46,7 +46,7 @@ export declare class MessageService {
         nativePush?: boolean;
         onClientMismatch?: (mismatch: MessageSendingStatus) => void | boolean | Promise<boolean>;
     }): Promise<MessageSendingStatus & {
-        errored?: boolean;
+        canceled?: boolean;
     }>;
     private sendFederatedOtrMessage;
     private sendOTRMessage;

package/lib/conversation/message/MessageService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageService.d.ts","sourceRoot":"","sources":["../../../src/conversation/message/MessageService.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,cAAc,EACd,oBAAoB,EAIpB,oBAAoB,EACpB,WAAW,EACZ,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAC,WAAW,EAAE,4BAA4B,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAQ5G,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAS9C,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,kCAAkC,CAAC;AAKrE,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAa,OAAO,CAAC,QAAQ,CAAC,cAAc;gBAArD,SAAS,EAAE,SAAS,EAAmB,cAAc,EAAE,cAAc;IAElG;;;;;;;;;;;OAWG;IACU,WAAW,CACtB,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,WAAW,GAAG,mBAAmB,EAC7C,SAAS,EAAE,UAAU,EACrB,OAAO,GAAE;QACP,cAAc,CAAC,EAAE,WAAW,CAAC;QAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;QACnC,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KAC/E,GACL,OAAO,CAAC,cAAc,GAAG;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC;IAgChD;;;;;;;;;;;OAWG;IACU,oBAAoB,CAC/B,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,oBAAoB,GAAG,4BAA4B,EAC/D,SAAS,EAAE,UAAU,EACrB,OAAO,EAAE;QACP,SAAS,CAAC,EAAE,UAAU,CAAC;QACvB,cAAc,CAAC,EAAE,WAAW,CAAC;QAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,WAAW,EAAE,CAAC;QACxC,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KAC1F,GACA,OAAO,CAAC,oBAAoB,GAAG;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC;YAsBxC,uBAAuB;YAiEvB,cAAc;YAmCd,uBAAuB;IAiBrC,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,qBAAqB;YAIf,sBAAsB;IAmBpC;;;;;;;OAOG;YACW,+BAA+B;YAuB/B,sBAAsB;CAoDrC"}
+{"version":3,"file":"MessageService.d.ts","sourceRoot":"","sources":["../../../src/conversation/message/MessageService.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,cAAc,EACd,oBAAoB,EAIpB,oBAAoB,EACpB,WAAW,EACZ,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAC,WAAW,EAAE,4BAA4B,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAQ5G,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAS9C,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,kCAAkC,CAAC;AAKrE,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAa,OAAO,CAAC,QAAQ,CAAC,cAAc;gBAArD,SAAS,EAAE,SAAS,EAAmB,cAAc,EAAE,cAAc;IAElG;;;;;;;;;;;OAWG;IACU,WAAW,CACtB,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,WAAW,GAAG,mBAAmB,EAC7C,SAAS,EAAE,UAAU,EACrB,OAAO,GAAE;QACP,cAAc,CAAC,EAAE,WAAW,CAAC;QAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;QACnC,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KAC/E,GACL,OAAO,CAAC,cAAc,GAAG;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC;IAgCjD;;;;;;;;;;;OAWG;IACU,oBAAoB,CAC/B,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,oBAAoB,GAAG,4BAA4B,EAC/D,SAAS,EAAE,UAAU,EACrB,OAAO,EAAE;QACP,SAAS,CAAC,EAAE,UAAU,CAAC;QACvB,cAAc,CAAC,EAAE,WAAW,CAAC;QAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,WAAW,EAAE,CAAC;QACxC,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KAC1F,GACA,OAAO,CAAC,oBAAoB,GAAG;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC;YAsBzC,uBAAuB;YAiEvB,cAAc;YAmCd,uBAAuB;IAiBrC,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,qBAAqB;YAIf,sBAAsB;IAmBpC;;;;;;;OAOG;YACW,+BAA+B;YAuB/B,sBAAsB;CAoDrC"}

package/lib/conversation/message/MessageService.js

@@ -75,7 +75,7 @@ class MessageService {
             const mismatch = error.response.data;
             const shouldStopSending = options.onClientMismatch && (await options.onClientMismatch(mismatch)) === false;
             if (shouldStopSending) {
-                return Object.assign(Object.assign({}, mismatch), { errored: true });
+                return Object.assign(Object.assign({}, mismatch), { canceled: true });
             }
             const reEncryptedMessage = await this.reencryptAfterMismatch(mismatch, encryptedPayload, plainText);
             return send(reEncryptedMessage);
@@ -108,7 +108,7 @@ class MessageService {
             const mismatch = error.response.data;
             const shouldStopSending = options.onClientMismatch && (await options.onClientMismatch(mismatch)) === false;
             if (shouldStopSending) {
-                return Object.assign(Object.assign({}, mismatch), { errored: true });
+                return Object.assign(Object.assign({}, mismatch), { canceled: true });
             }
             const reEncryptedPayload = await this.reencryptAfterFederatedMismatch(mismatch, encryptedPayload, plainText);
             return send(reEncryptedPayload);

package/lib/conversation/message/MessageService.test.js

@@ -89,14 +89,15 @@ const buildMessageService = async () => {
 };
 describe('MessageService', () => {
     describe('sendFederatedMessage', () => {
-        it('sends a message', async () => {
+        it('sends a message and forwards backend response', async () => {
             const [messageService, { apiClient }] = await buildMessageService();
             jest.spyOn(apiClient.api.conversation, 'postOTRMessageV2').mockResolvedValue(baseMessageSendingStatus);
             const recipients = generateQualifiedRecipients([user1, user2]);
-            await messageService.sendFederatedMessage('senderclientid', recipients, new Uint8Array(), {
+            const result = await messageService.sendFederatedMessage('senderclientid', recipients, new Uint8Array(), {
                 conversationId: { id: 'convid', domain: '' },
             });
             expect(apiClient.api.conversation.postOTRMessageV2).toHaveBeenCalled();
+            expect(result).toEqual(baseMessageSendingStatus);
         });
         describe('client mismatch', () => {
             it('handles client mismatch internally if no onClientMismatch is given', async () => {

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProteusService.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AACjE,OAAO,KAAK,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EACV,YAAY,EAEZ,aAAa,EACb,sBAAsB,EACtB,oBAAoB,EACpB,WAAW,EACZ,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAC,WAAW,EAAE,4BAA4B,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAIjH,OAAO,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAEjD,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAG5C,OAAO,KAAK,EACV,mCAAmC,EACnC,+BAA+B,EAC/B,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAA0C,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAE1F,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAC,kBAAkB,EAAqB,MAAM,iBAAiB,CAAC;AAWvE,qBAAa,cAAc;IAKvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;gBAG/C,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,oBAAoB;IAKlC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,GAAG,kBAAkB;IAiBhG,UAAU,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO;IA0B1D,YAAY,CAAC,OAAO,CAAC,EAAE,UAAU;IAIxC;;OAEG;IACI,mBAAmB;IAInB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;IAIlG;;;;;;OAMG;IACU,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAQ3E,kBAAkB,CAAC,EAC9B,gBAAgB,EAChB,YAAY,GACb,EAAE,+BAA+B,GAAG,OAAO,CAAC,YAAY,CAAC;IAiB7C,sBAAsB,CAAC,EAAC,cAAc,EAAE,gBAAgB,EAAC,EAAE,mCAAmC;IAI9F,WAAW,CAAC,EACvB,OAAO,EACP,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,EACV,OAAO,EACP,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,OAAO,CAAC,UAAU,CAAC;YA2CnC,OAAO;IAuBR,OAAO,CAClB,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,mBAAmB,GAAG,WAAW,EAC7C,MAAM,GAAE,MAAW,GAClB,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IAc9B,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM;IAS7C,gBAAgB,CAC3B,SAAS,EAAE,UAAU,EACrB,aAAa,EAAE,4BAA4B,GAAG,oBAAoB,GACjE,OAAO,CAAC,sBAAsB,CAAC;IAWlC,IAAI;CAGL"}
+{"version":3,"file":"ProteusService.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AACjE,OAAO,KAAK,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EACV,YAAY,EAEZ,aAAa,EACb,sBAAsB,EACtB,oBAAoB,EACpB,WAAW,EACZ,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAC,WAAW,EAAE,4BAA4B,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAIjH,OAAO,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAEjD,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAG5C,OAAO,KAAK,EACV,mCAAmC,EACnC,+BAA+B,EAC/B,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAA0C,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAE1F,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAC,kBAAkB,EAAqB,MAAM,iBAAiB,CAAC;AAWvE,qBAAa,cAAc;IAKvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;gBAG/C,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,oBAAoB;IAKlC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,GAAG,kBAAkB;IAiBhG,UAAU,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO;IA0B1D,YAAY,CAAC,OAAO,CAAC,EAAE,UAAU;IAIxC;;OAEG;IACI,mBAAmB;IAInB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;IAIlG;;;;;;OAMG;IACU,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAQ3E,kBAAkB,CAAC,EAC9B,gBAAgB,EAChB,YAAY,GACb,EAAE,+BAA+B,GAAG,OAAO,CAAC,YAAY,CAAC;IAiB7C,sBAAsB,CAAC,EAAC,cAAc,EAAE,gBAAgB,EAAC,EAAE,mCAAmC;IAI9F,WAAW,CAAC,EACvB,OAAO,EACP,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,EACV,OAAO,EACP,gBAAgB,GACjB,EAAE,wBAAwB,GAAG,OAAO,CAAC,UAAU,CAAC;YAmDnC,OAAO;IAuBR,OAAO,CAClB,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,mBAAmB,GAAG,WAAW,EAC7C,MAAM,GAAE,MAAW,GAClB,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IAc9B,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM;IAS7C,gBAAgB,CAC3B,SAAS,EAAE,UAAU,EACrB,aAAa,EAAE,4BAA4B,GAAG,oBAAoB,GACjE,OAAO,CAAC,sBAAsB,CAAC;IAWlC,IAAI;CAGL"}

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.js

@@ -137,17 +137,22 @@ class ProteusService {
         const response = federated
             ? await this.messageService.sendFederatedMessage(sendingClientId, recipients, plainText, Object.assign(Object.assign({}, options), { onClientMismatch: mismatch => onClientMismatch === null || onClientMismatch === void 0 ? void 0 : onClientMismatch(mismatch, false) }))
             : await this.messageService.sendMessage(sendingClientId, recipients, plainText, Object.assign(Object.assign({}, options), { sendAsProtobuf, onClientMismatch: mismatch => onClientMismatch === null || onClientMismatch === void 0 ? void 0 : onClientMismatch(mismatch, false) }));
-        if (!response.errored) {
+        if (!response.canceled) {
             if (!(0, isClearFromMismatch_1.isClearFromMismatch)(response)) {
                 // We warn the consumer that there is a mismatch that did not prevent message sending
                 await (onClientMismatch === null || onClientMismatch === void 0 ? void 0 : onClientMismatch(response, true));
             }
             this.logger.log(`Successfully sent Proteus message to conversation '${conversationId.id}'`);
         }
+        const sendingState = response.canceled ? conversation_1.MessageSendingState.CANCELED : conversation_1.MessageSendingState.OUTGOING_SENT;
+        const failedToSend = 'failed_to_send' in response && Object.keys(response.failed_to_send).length > 0
+            ? response.failed_to_send
+            : undefined;
         return {
             id: payload.messageId,
             sentAt: response.time,
-            state: response.errored ? conversation_1.MessageSendingState.CANCELLED : conversation_1.MessageSendingState.OUTGOING_SENT,
+            state: sendingState,
+            failedToSend,
         };
     }
     async decrypt(encryptedText, userId, clientId) {

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.mocks.d.ts

@@ -1,8 +1,8 @@
 import { APIClient } from '@wireapp/api-client';
-import { CoreCrypto } from '@wireapp/core-crypto';
+import { CryptoClient } from './CryptoClient';
 import { ProteusService } from './ProteusService';
 export declare const buildProteusService: (federated?: boolean) => Promise<[ProteusService, {
     apiClient: APIClient;
-    coreCrypto: CoreCrypto;
+    cryptoClient: CryptoClient;
 }]>;
 //# sourceMappingURL=ProteusService.mocks.d.ts.map

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.mocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProteusService.mocks.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.mocks.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAGhD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAIhD,eAAO,MAAM,mBAAmB;eAEQ,SAAS;gBAAc,UAAU;GAgBxE,CAAC"}
+{"version":3,"file":"ProteusService.mocks.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/ProteusService/ProteusService.mocks.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAE9C,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAIhD,eAAO,MAAM,mBAAmB;eAEQ,SAAS;kBAAgB,YAAY;GAgB5E,CAAC"}

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.mocks.js

@@ -21,7 +21,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildProteusService = void 0;
 const client_1 = require("@wireapp/api-client/lib/client");
 const api_client_1 = require("@wireapp/api-client");
-const core_crypto_1 = require("@wireapp/core-crypto");
 const CoreCryptoWrapper_1 = require("./CryptoClient/CoreCryptoWrapper");
 const ProteusService_1 = require("./ProteusService");
 const PayloadHelper_1 = require("../../../test/PayloadHelper");
@@ -32,11 +31,11 @@ const buildProteusService = async (federated = false) => {
         userId: (0, PayloadHelper_1.getUUID)(),
         clientId: (0, PayloadHelper_1.getUUID)(),
     };
-    const coreCrypto = await core_crypto_1.CoreCrypto.deferredInit('store-name', 'key');
-    const proteusService = new ProteusService_1.ProteusService(apiClient, new CoreCryptoWrapper_1.CoreCryptoWrapper(coreCrypto, {}, {}), {
+    const cryptoClient = new CoreCryptoWrapper_1.CoreCryptoWrapper({}, {}, {});
+    const proteusService = new ProteusService_1.ProteusService(apiClient, cryptoClient, {
         nbPrekeys: 0,
         useQualifiedIds: federated,
     });
-    return [proteusService, { apiClient, coreCrypto }];
+    return [proteusService, { apiClient, cryptoClient }];
 };
 exports.buildProteusService = buildProteusService;

package/lib/messagingProtocols/proteus/ProteusService/ProteusService.test.js

@@ -65,7 +65,7 @@ jest.mock('./CryptoClient/PrekeysTracker', () => {
 jest.mock('../Utility/Recipients', () => (Object.assign(Object.assign({}, jest.requireActual('../Utility/Recipients')), { getRecipientsForConversation: jest.fn(), getQualifiedRecipientsForConversation: jest.fn() })));
 const MockedRecipients = Recipients;
 const prepareDataForEncryption = async (useQualifiedIds = true) => {
-    const [proteusService, { coreCrypto, apiClient }] = await (0, ProteusService_mocks_1.buildProteusService)(useQualifiedIds);
+    const [proteusService, { cryptoClient, apiClient }] = await (0, ProteusService_mocks_1.buildProteusService)(useQualifiedIds);
     const domain = 'staging.zinfra.io';
     //user 1
     const firstUserId = 'bc0c99f1-49a5-4ad2-889a-62885af37088';
@@ -88,7 +88,7 @@ const prepareDataForEncryption = async (useQualifiedIds = true) => {
     //user 2
     const secondUserId = 'cd0c88f1-49a5-4ar2-889a-62885af37069';
     //user 2 client
-    const thirdClientId = 'be67218b77d02d69';
+    const thirdClientId = 'ce67218b77d02d69';
     //user 2 sessions
     const secondClientSessionId = (0, SessionHandler_1.constructSessionId)({
         userId: secondUserId,
@@ -107,7 +107,7 @@ const prepareDataForEncryption = async (useQualifiedIds = true) => {
         key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
     };
     return {
-        services: { proteusService, apiClient, coreCryptoClient: coreCrypto },
+        services: { proteusService, apiClient, cryptoClient },
         data: {
             firstUser: {
                 id: firstUserId,
@@ -130,29 +130,35 @@ const prepareDataForEncryption = async (useQualifiedIds = true) => {
 describe('ProteusService', () => {
     describe('getRemoteFingerprint', () => {
         it('create a session if session does not exists', async () => {
-            const [proteusService, { apiClient, coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            const [proteusService, { apiClient, cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
             const expectedFingerprint = 'fingerprint-client1';
-            const getPrekeyMock = jest.spyOn(apiClient.api.user, 'getClientPreKey').mockResolvedValue({
-                client: 'client1',
-                prekey: {
-                    id: 123,
-                    key: 'pQABARhIAqEAWCCaJpFa9c626ORmjj1aV6OnOYgmTjfoiE3ynOfNfGAOmgOhAKEAWCD60VMzRrLfO+1GSjgyhnVp2N7L58DM+eeJhZJi1tBLfQT2',
-                },
-            });
-            jest.spyOn(coreCrypto, 'proteusFingerprintRemote').mockResolvedValue(expectedFingerprint);
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(false);
             const userId = { id: 'user1', domain: 'domain.com' };
             const clientId = 'client1';
+            jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockResolvedValue({
+                [userId.domain]: {
+                    [userId.id]: {
+                        [clientId]: {
+                            id: 123,
+                            key: 'pQABARhIAqEAWCCaJpFa9c626ORmjj1aV6OnOYgmTjfoiE3ynOfNfGAOmgOhAKEAWCD60VMzRrLfO+1GSjgyhnVp2N7L58DM+eeJhZJi1tBLfQT2',
+                        },
+                    },
+                },
+            });
+            jest.spyOn(cryptoClient, 'getRemoteFingerprint').mockResolvedValue(expectedFingerprint);
+            jest.spyOn(cryptoClient, 'sessionFromPrekey').mockResolvedValue(undefined);
+            jest.spyOn(cryptoClient, 'saveSession').mockResolvedValue(undefined);
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
             const result = await proteusService.getRemoteFingerprint(userId, clientId);
-            expect(getPrekeyMock).toHaveBeenCalledWith(userId, clientId);
             expect(result).toBe(expectedFingerprint);
         });
         it('create a session from given prekey if session does not exists', async () => {
-            const [proteusService, { apiClient, coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            const [proteusService, { apiClient, cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
             const expectedFingerprint = 'fingerprint-client1';
             const getPrekeyMock = jest.spyOn(apiClient.api.user, 'getClientPreKey');
-            jest.spyOn(coreCrypto, 'proteusFingerprintRemote').mockResolvedValue(expectedFingerprint);
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(false);
+            jest.spyOn(cryptoClient, 'getRemoteFingerprint').mockResolvedValue(expectedFingerprint);
+            jest.spyOn(cryptoClient, 'sessionFromPrekey').mockResolvedValue(undefined);
+            jest.spyOn(cryptoClient, 'saveSession').mockResolvedValue(undefined);
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
             const userId = { id: 'user1', domain: 'domain.com' };
             const clientId = 'client1';
             const result = await proteusService.getRemoteFingerprint(userId, clientId, {
@@ -163,12 +169,12 @@ describe('ProteusService', () => {
             expect(result).toBe(expectedFingerprint);
         });
         it('returns the fingerprint from existing session', async () => {
-            const [proteusService, { apiClient, coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            const [proteusService, { apiClient, cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
             const expectedFingerprint = 'fingerprint-client1';
             const getPrekeyMock = jest.spyOn(apiClient.api.user, 'getClientPreKey');
-            const sessionFromPrekeyMock = jest.spyOn(coreCrypto, 'proteusSessionFromPrekey');
-            jest.spyOn(coreCrypto, 'proteusFingerprintRemote').mockResolvedValue(expectedFingerprint);
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(true);
+            const sessionFromPrekeyMock = jest.spyOn(cryptoClient, 'sessionFromPrekey');
+            jest.spyOn(cryptoClient, 'getRemoteFingerprint').mockResolvedValue(expectedFingerprint);
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(true);
             const userId = { id: 'user1', domain: 'domain.com' };
             const clientId = 'client1';
             const result = await proteusService.getRemoteFingerprint(userId, clientId);
@@ -188,9 +194,10 @@ describe('ProteusService', () => {
         };
         const decryptedMessage = {};
         it('decrypts incoming proteus encrypted events when session already exists', async () => {
-            const [proteusService, { coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(true);
-            const createSessionSpy = jest.spyOn(coreCrypto, 'proteusSessionFromMessage');
+            const [proteusService, { cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(true);
+            const createSessionSpy = jest.spyOn(cryptoClient, 'sessionFromMessage');
+            jest.spyOn(cryptoClient, 'decrypt').mockResolvedValue(new Uint8Array());
             jest.spyOn(protocol_messaging_1.GenericMessage, 'decode').mockReturnValue(decryptedMessage);
             const result = await proteusService.handleEvent(eventPayload);
             expect(result).toBeDefined();
@@ -198,10 +205,11 @@ describe('ProteusService', () => {
             expect(result === null || result === void 0 ? void 0 : result.decryptedData).toBe(decryptedMessage);
         });
         it('decrypts incoming proteus encrypted and creates session if not already existing', async () => {
-            const [proteusService, { coreCrypto }] = await (0, ProteusService_mocks_1.buildProteusService)();
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(false);
-            const createSessionSpy = jest.spyOn(coreCrypto, 'proteusSessionFromMessage');
-            const decryptSpy = jest.spyOn(coreCrypto, 'proteusDecrypt');
+            const [proteusService, { cryptoClient }] = await (0, ProteusService_mocks_1.buildProteusService)();
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
+            jest.spyOn(cryptoClient, 'saveSession').mockResolvedValue(undefined);
+            const createSessionSpy = jest.spyOn(cryptoClient, 'sessionFromMessage').mockResolvedValue(new Uint8Array());
+            const decryptSpy = jest.spyOn(cryptoClient, 'decrypt');
             jest.spyOn(protocol_messaging_1.GenericMessage, 'decode').mockReturnValue(decryptedMessage);
             const result = await proteusService.handleEvent(eventPayload);
             expect(result).toBeDefined();
@@ -212,28 +220,18 @@ describe('ProteusService', () => {
     });
     describe('"encrypt"', () => {
         it('returns encrypted payload', async () => {
-            const { services, data: { firstUser, validPreKey, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
+            const { services, data: { firstUser, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
             const userClients = {
                 [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
             };
-            const preKeyBundleMap = {
-                [firstUser.id]: {
-                    [firstUser.clients.first]: validPreKey,
-                    [firstUser.clients.second]: validPreKey,
-                },
-            };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
                 [firstUser.sessions.second, encryptedMessageBuffer],
             ]);
-            jest
-                .spyOn(services.apiClient.api.user, 'postMultiPreKeyBundles')
-                .mockImplementationOnce(() => Promise.resolve(preKeyBundleMap));
-            jest
-                .spyOn(services.coreCryptoClient, 'proteusEncryptBatched')
-                .mockImplementationOnce(() => Promise.resolve(encryptedPayload));
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
+            jest.spyOn(services.cryptoClient, 'encrypt').mockImplementationOnce(() => Promise.resolve(encryptedPayload));
             const encrypted = await services.proteusService.encrypt(messageBuffer, userClients);
-            expect(services.coreCryptoClient.proteusEncryptBatched).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
             expect(encrypted).toEqual({
                 [firstUser.id]: {
                     [firstUser.clients.first]: encryptedMessageBuffer,
@@ -242,33 +240,20 @@ describe('ProteusService', () => {
             });
         });
         it('returns encrypted payload for multiple users', async () => {
-            const { services, data: { firstUser, secondUser, validPreKey, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
+            const { services, data: { firstUser, secondUser, encryptedMessageBuffer, messageBuffer }, } = await prepareDataForEncryption(false);
             const userClients = {
                 [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
                 [secondUser.id]: [secondUser.clients.first],
             };
-            const preKeyBundleMap = {
-                [firstUser.id]: {
-                    [firstUser.clients.first]: validPreKey,
-                    [firstUser.clients.second]: null,
-                },
-                [secondUser.id]: {
-                    [secondUser.clients.first]: validPreKey,
-                },
-            };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
                 [firstUser.sessions.second, encryptedMessageBuffer],
                 [secondUser.sessions.first, encryptedMessageBuffer],
             ]);
-            jest
-                .spyOn(services.apiClient.api.user, 'postMultiPreKeyBundles')
-                .mockImplementationOnce(() => Promise.resolve(preKeyBundleMap));
-            jest
-                .spyOn(services.coreCryptoClient, 'proteusEncryptBatched')
-                .mockImplementationOnce(() => Promise.resolve(encryptedPayload));
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
+            jest.spyOn(services.cryptoClient, 'encrypt').mockResolvedValueOnce(encryptedPayload);
             const encrypted = await services.proteusService.encrypt(messageBuffer, userClients);
-            expect(services.coreCryptoClient.proteusEncryptBatched).toHaveBeenCalledWith([firstUser.sessions.first, secondUser.sessions.first], messageBuffer);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second, secondUser.sessions.first], messageBuffer);
             expect(encrypted).toEqual({
                 [firstUser.id]: {
                     [firstUser.clients.first]: encryptedMessageBuffer,
@@ -282,33 +267,21 @@ describe('ProteusService', () => {
     });
     describe('"encryptQualified"', () => {
         it('returns encrypted payload', async () => {
-            const { services, data: { firstUser, validPreKey, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
+            const { services, data: { firstUser, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
             const userClients = {
                 [domain]: {
                     [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
                 },
             };
-            const preKeyBundleMap = {
-                [domain]: {
-                    [firstUser.id]: {
-                        [firstUser.clients.first]: validPreKey,
-                        [firstUser.clients.second]: validPreKey,
-                    },
-                },
-            };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
                 [firstUser.sessions.second, encryptedMessageBuffer],
             ]);
-            jest
-                .spyOn(services.apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
-                .mockImplementationOnce(() => Promise.resolve(preKeyBundleMap));
-            jest
-                .spyOn(services.coreCryptoClient, 'proteusEncryptBatched')
-                .mockImplementationOnce(() => Promise.resolve(encryptedPayload));
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
+            jest.spyOn(services.cryptoClient, 'encrypt').mockResolvedValueOnce(encryptedPayload);
             const encrypted = await services.proteusService.encryptQualified(messageBuffer, userClients);
             // console.log({encrypted, missing});
-            expect(services.coreCryptoClient.proteusEncryptBatched).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second], messageBuffer);
             expect(encrypted).toEqual({
                 [domain]: {
                     [firstUser.id]: {
@@ -319,40 +292,27 @@ describe('ProteusService', () => {
             });
         });
         it('returns missing clients and encrypted payload for multiple users', async () => {
-            const { services, data: { firstUser, secondUser, validPreKey, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
+            const { services, data: { firstUser, secondUser, encryptedMessageBuffer, messageBuffer, domain }, } = await prepareDataForEncryption();
             const userClients = {
                 [domain]: {
                     [firstUser.id]: [firstUser.clients.first, firstUser.clients.second],
                     [secondUser.id]: [secondUser.clients.first],
                 },
             };
-            const preKeyBundleMap = {
-                [domain]: {
-                    [firstUser.id]: {
-                        [firstUser.clients.first]: validPreKey,
-                        [firstUser.clients.second]: null,
-                    },
-                    [secondUser.id]: {
-                        [secondUser.clients.first]: validPreKey,
-                    },
-                },
-            };
             const encryptedPayload = new Map([
                 [firstUser.sessions.first, encryptedMessageBuffer],
+                [firstUser.sessions.second, encryptedMessageBuffer],
                 [secondUser.sessions.first, encryptedMessageBuffer],
             ]);
-            jest
-                .spyOn(services.apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
-                .mockImplementationOnce(() => Promise.resolve(preKeyBundleMap));
-            jest
-                .spyOn(services.coreCryptoClient, 'proteusEncryptBatched')
-                .mockImplementationOnce(() => Promise.resolve(encryptedPayload));
+            jest.spyOn(services.cryptoClient, 'sessionExists').mockResolvedValue(true);
+            jest.spyOn(services.cryptoClient, 'encrypt').mockResolvedValueOnce(encryptedPayload);
             const encrypted = await services.proteusService.encryptQualified(messageBuffer, userClients);
-            expect(services.coreCryptoClient.proteusEncryptBatched).toHaveBeenCalledWith([firstUser.sessions.first, secondUser.sessions.first], messageBuffer);
+            expect(services.cryptoClient.encrypt).toHaveBeenCalledWith([firstUser.sessions.first, firstUser.sessions.second, secondUser.sessions.first], messageBuffer);
             expect(encrypted).toEqual({
                 [domain]: {
                     [firstUser.id]: {
                         [firstUser.clients.first]: encryptedMessageBuffer,
+                        [firstUser.clients.second]: encryptedMessageBuffer,
                     },
                     [secondUser.id]: {
                         [secondUser.clients.first]: encryptedMessageBuffer,
@@ -468,6 +428,30 @@ describe('ProteusService', () => {
                     }));
                 });
             });
+            it(`returns the recipients that could not receive the message`, async () => {
+                const [proteusService] = await (0, ProteusService_mocks_1.buildProteusService)(true);
+                const recipients = {
+                    domain1: { user1: ['client1'], user2: ['client11', 'client12'] },
+                    domain2: { user3: ['client3'] },
+                };
+                MockedRecipients.getQualifiedRecipientsForConversation.mockResolvedValue({});
+                jest.spyOn(proteusService['messageService'], 'sendFederatedMessage').mockResolvedValue({
+                    missing: {},
+                    redundant: {},
+                    failed_to_send: { domain2: recipients.domain2 },
+                    time: new Date().toISOString(),
+                    deleted: {},
+                });
+                const result = await proteusService.sendMessage({
+                    protocol: conversation_1.ConversationProtocol.PROTEUS,
+                    conversationId: { id: 'conv1', domain: 'domain1' },
+                    payload: message,
+                    targetMode: conversation_2.MessageTargetMode.USERS_CLIENTS,
+                    userIds: recipients,
+                });
+                expect(result.state).toBe(conversation_2.MessageSendingState.OUTGOING_SENT);
+                expect(result.failedToSend).toEqual({ domain2: recipients.domain2 });
+            });
         });
     });
 });

package/lib/messagingProtocols/proteus/ProteusService/WithMockedGenerics.test.js

@@ -81,14 +81,14 @@ describe('sendGenericMessage', () => {
             });
             jest
                 .spyOn(proteusService['messageService'], 'sendMessage')
-                .mockReturnValue(Promise.resolve({ time: '', errored: true }));
+                .mockReturnValue(Promise.resolve({ time: '', canceled: true }));
             const message = (0, MessageBuilder_1.buildTextMessage)({ text: 'test' });
             const payloadBundle = await proteusService.sendMessage({
                 payload: message,
                 conversationId: { id: 'conv1', domain: '' },
                 protocol: conversation_1.ConversationProtocol.PROTEUS,
             });
-            expect(payloadBundle.state).toBe(conversation_2.MessageSendingState.CANCELLED);
+            expect(payloadBundle.state).toBe(conversation_2.MessageSendingState.CANCELED);
         });
     });
 });

package/lib/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SessionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAC,WAAW,EAAC,MAAM,sCAAsC,CAAC;AACjE,OAAO,EAAC,WAAW,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAE9E,OAAO,EAAC,MAAM,EAAC,MAAM,SAAS,CAAC;AAE/B,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAK9C,OAAO,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAE/D,UAAU,wBAAwB;IAChC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,QAAA,MAAM,kBAAkB,kDAAiD,wBAAwB,KAAG,MAKnG,CAAC;AA2GF;;;GAGG;AACH,QAAA,MAAM,WAAW;YAC6B,WAAW;cAAY,MAAM;;;eAClC,SAAS;kBAAgB,YAAY;MAC3E,QAAQ,MAAM,CAYhB,CAAC;AAyBF,UAAU,wCAAwC;IAChD,UAAU,EAAE,WAAW,GAAG,mBAAmB,CAAC;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,QAAA,MAAM,YAAY,6DAMf,wCAAwC,KAAG,QAAQ,MAAM,EAAE,CAgC7D,CAAC;AAEF,UAAU,mBAAmB;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC1B;AACD,iBAAe,aAAa,CAAC,MAAM,EAAE,mBAAmB,iBAGvD;AA+CD,KAAK,iBAAiB,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9D;;GAEG;AACH,QAAA,MAAM,sBAAsB,uDAO3B,CAAC;AAEF,OAAO,EAAC,kBAAkB,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAC,CAAC"}
+{"version":3,"file":"SessionHandler.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAC,WAAW,EAAC,MAAM,sCAAsC,CAAC;AACjE,OAAO,EAAC,WAAW,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAE9E,OAAO,EAAC,MAAM,EAAC,MAAM,SAAS,CAAC;AAE/B,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAK9C,OAAO,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAE/D,UAAU,wBAAwB;IAChC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,QAAA,MAAM,kBAAkB,kDAAiD,wBAAwB,KAAG,MAKnG,CAAC;AAuFF;;;GAGG;AACH,QAAA,MAAM,WAAW;YAC6B,WAAW;cAAY,MAAM;;;eAClC,SAAS;kBAAgB,YAAY;MAC3E,QAAQ,MAAM,CAmBhB,CAAC;AAyBF,UAAU,wCAAwC;IAChD,UAAU,EAAE,WAAW,GAAG,mBAAmB,CAAC;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,QAAA,MAAM,YAAY,6DAMf,wCAAwC,KAAG,QAAQ,MAAM,EAAE,CAgC7D,CAAC;AAEF,UAAU,mBAAmB;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC1B;AACD,iBAAe,aAAa,CAAC,MAAM,EAAE,mBAAmB,iBAGvD;AA+CD,KAAK,iBAAiB,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9D;;GAEG;AACH,QAAA,MAAM,sBAAsB,uDAO3B,CAAC;AAEF,OAAO,EAAC,kBAAkB,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAC,CAAC"}

package/lib/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.js

@@ -43,13 +43,6 @@ const parseSessionId = (sessionId) => {
     }
     return match.groups;
 };
-const createSession = async ({ sessionId, initialPrekey, cryptoClient, apiClient, }) => {
-    const { userId, clientId, domain } = parseSessionId(sessionId);
-    const prekey = initialPrekey !== null && initialPrekey !== void 0 ? initialPrekey : (await apiClient.api.user.getClientPreKey({ id: userId, domain: domain !== null && domain !== void 0 ? domain : '' }, clientId)).prekey;
-    const prekeyBuffer = bazinga64_1.Decoder.fromBase64(prekey.key).asBytes;
-    await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
-    await cryptoClient.saveSession(sessionId);
-};
 const createLegacySessions = async ({ userClients, apiClient, cryptoClient, logger, }) => {
     const preKeyBundleMap = await apiClient.api.user.postMultiPreKeyBundles(userClients);
     const sessions = await createSessionsFromPreKeys({
@@ -87,15 +80,22 @@ const createQualifiedSessions = async ({ userClientMap, domain, apiClient, crypt
 const initSession = async ({ userId, clientId, initialPrekey }, { cryptoClient, apiClient }) => {
     const sessionId = constructSessionId({ userId, clientId, useQualifiedIds: !!userId.domain });
     const sessionExists = await cryptoClient.sessionExists(sessionId);
-    if (!sessionExists) {
-        await createSession({
-            sessionId,
-            initialPrekey,
-            apiClient: apiClient,
-            cryptoClient,
-        });
+    if (sessionExists) {
+        return sessionId;
+    }
+    if (initialPrekey) {
+        const prekeyBuffer = bazinga64_1.Decoder.fromBase64(initialPrekey.key).asBytes;
+        await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
+        await cryptoClient.saveSession(sessionId);
+        return sessionId;
     }
-    return sessionId;
+    const sessions = await initSessions({
+        recipients: { [userId.id]: [clientId] },
+        domain: userId.domain,
+        apiClient,
+        cryptoClient,
+    });
+    return sessions[0];
 };
 exports.initSession = initSession;
 /**

package/lib/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.test.js

@@ -18,10 +18,28 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const api_client_1 = require("@wireapp/api-client");
 const SessionHandler_1 = require("./SessionHandler");
-const CoreCryptoWrapper_1 = require("../../ProteusService/CryptoClient/CoreCryptoWrapper");
-const ProteusService_mocks_1 = require("../../ProteusService/ProteusService.mocks");
+function generatePrekeys(userId, clientIds) {
+    const clients = clientIds.reduce((prekeys, clientId, index) => {
+        return Object.assign(Object.assign({}, prekeys), { [clientId]: {
+                id: index,
+                key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
+            } });
+    }, {});
+    return {
+        [userId.id]: Object.assign({}, clients),
+    };
+}
 describe('SessionHandler', () => {
+    const cryptoClient = {
+        sessionFromMessage: jest.fn(),
+        sessionFromPrekey: jest.fn(),
+        sessionExists: jest.fn(),
+        saveSession: jest.fn(),
+        deleteSession: jest.fn(),
+    };
+    const apiClient = new api_client_1.APIClient({ urls: api_client_1.APIClient.BACKEND.STAGING });
     describe('constructSessionId', () => {
         describe('constructs a session ID', () => {
             it('without a domain', () => {
@@ -66,35 +84,42 @@ describe('SessionHandler', () => {
     });
     describe('initSession', () => {
         it('only returns sessions that already exists', async () => {
-            const { apiClient, coreCrypto } = (await (0, ProteusService_mocks_1.buildProteusService)())[1];
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(true);
-            const sessionFromPrekeySpy = jest.spyOn(coreCrypto, 'proteusSessionFromPrekey');
-            await (0, SessionHandler_1.initSession)({ userId: { id: 'user1', domain: 'domain' }, clientId: 'client1' }, { apiClient, cryptoClient: new CoreCryptoWrapper_1.CoreCryptoWrapper(coreCrypto, {}, {}) });
-            expect(sessionFromPrekeySpy).not.toHaveBeenCalled();
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(true);
+            await (0, SessionHandler_1.initSession)({ userId: { id: 'user1', domain: 'domain' }, clientId: 'client1' }, { apiClient, cryptoClient });
+            expect(cryptoClient.sessionFromPrekey).not.toHaveBeenCalled();
         });
         it('creates the session if it does not already exist', async () => {
-            const { apiClient, coreCrypto } = (await (0, ProteusService_mocks_1.buildProteusService)())[1];
-            jest.spyOn(coreCrypto, 'proteusSessionExists').mockResolvedValue(false);
-            jest.spyOn(apiClient.api.user, 'getClientPreKey').mockResolvedValue({
-                prekey: {
-                    id: 1,
-                    key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-                },
-                client: 'client1',
+            const userId = { id: 'user1', domain: 'domain' };
+            const clientId = 'client1';
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
+            jest
+                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
+                .mockResolvedValue({ domain: generatePrekeys(userId, [clientId]) });
+            const sessionId = (0, SessionHandler_1.constructSessionId)({
+                userId,
+                clientId,
+                useQualifiedIds: true,
             });
+            await (0, SessionHandler_1.initSession)({ userId, clientId }, { apiClient, cryptoClient });
+            expect(cryptoClient.sessionFromPrekey).toHaveBeenCalledWith(sessionId, expect.any(Object));
+        });
+        it('indicates the consumer if a session could not be created', async () => {
+            const userId = { id: 'user1', domain: 'domain' };
+            const clientId = 'client1';
+            jest
+                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
+                .mockResolvedValue({ domain: generatePrekeys(userId, [clientId]) });
             const sessionId = (0, SessionHandler_1.constructSessionId)({
-                userId: { id: 'user1', domain: 'domain' },
-                clientId: 'client1',
+                userId,
+                clientId,
                 useQualifiedIds: true,
             });
-            const sessionFromPrekeySpy = jest.spyOn(coreCrypto, 'proteusSessionFromPrekey');
-            await (0, SessionHandler_1.initSession)({ userId: { id: 'user1', domain: 'domain' }, clientId: 'client1' }, { apiClient, cryptoClient: new CoreCryptoWrapper_1.CoreCryptoWrapper(coreCrypto, {}, {}) });
-            expect(sessionFromPrekeySpy).toHaveBeenCalledWith(sessionId, expect.any(Object));
+            await (0, SessionHandler_1.initSession)({ userId, clientId }, { apiClient, cryptoClient });
+            expect(cryptoClient.sessionFromPrekey).toHaveBeenCalledWith(sessionId, expect.any(Object));
         });
     });
     describe('initSessions', () => {
         it('creates new sessions only for sessions that are missing', async () => {
-            const { apiClient, coreCrypto } = (await (0, ProteusService_mocks_1.buildProteusService)())[1];
             const existingUserClients = {
                 'existing-user1': ['client1'],
                 'existing-user2': ['client1', 'client2'],
@@ -104,32 +129,15 @@ describe('SessionHandler', () => {
                 'missing-user2': ['client1', 'client2'],
             };
             jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockResolvedValue({});
-            jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue({
-                'missing-user1': {
-                    client1: {
-                        id: 1,
-                        key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-                    },
-                },
-                'missing-user2': {
-                    client1: {
-                        id: 1,
-                        key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-                    },
-                    client2: {
-                        id: 1,
-                        key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-                    },
-                },
-            });
+            jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue(Object.assign(Object.assign({}, generatePrekeys({ id: 'missing-user1', domain: '' }, ['client1'])), generatePrekeys({ id: 'missing-user2', domain: '' }, ['client1', 'client2'])));
             jest
-                .spyOn(coreCrypto, 'proteusSessionExists')
+                .spyOn(cryptoClient, 'sessionExists')
                 .mockImplementation(sessionId => Promise.resolve(sessionId.includes('missing')));
-            const sessionFromPrekeySpy = jest.spyOn(coreCrypto, 'proteusSessionFromPrekey');
+            const sessionFromPrekeySpy = jest.spyOn(cryptoClient, 'sessionFromPrekey');
             const sessions = await (0, SessionHandler_1.initSessions)({
                 recipients: Object.assign(Object.assign({}, existingUserClients), missingUserClients),
                 apiClient,
-                cryptoClient: new CoreCryptoWrapper_1.CoreCryptoWrapper(coreCrypto, {}, {}),
+                cryptoClient,
             });
             expect(sessionFromPrekeySpy).toHaveBeenCalledTimes(3);
             expect(sessions).toHaveLength(6);

package/package.json

@@ -11,7 +11,7 @@
     "./lib/cryptography/AssetCryptography/crypto.node": "./lib/cryptography/AssetCryptography/crypto.browser.js"
   },
   "dependencies": {
-    "@wireapp/api-client": "^22.15.0",
+    "@wireapp/api-client": "^22.15.1",
     "@wireapp/commons": "^5.0.4",
     "@wireapp/core-crypto": "0.6.0-rc.3",
     "@wireapp/cryptobox": "12.8.0",
@@ -19,7 +19,7 @@
     "@wireapp/protocol-messaging": "1.44.0",
     "@wireapp/store-engine": "5.0.3",
     "@wireapp/store-engine-dexie": "^2.0.5",
-    "axios": "1.2.6",
+    "axios": "1.3.0",
     "bazinga64": "6.0.3",
     "hash.js": "1.1.7",
     "http-status-codes": "2.2.0",
@@ -60,6 +60,6 @@
     "test:coverage": "jest --coverage",
     "watch": "tsc --watch"
   },
-  "version": "38.8.2",
-  "gitHead": "a3496f10bd03a239ba33affb747c3c9edf087599"
+  "version": "38.9.0",
+  "gitHead": "5f56977765637ca340d3934a66b89ec738db614a"
 }