@lifeready/core 9.0.6 → 9.0.7

package/bundles/lifeready-core.umd.js

@@ -8261,12 +8261,12 @@
         KeyExchangeService.prototype.getOtKey = function (keyExchange, otKeyK) {
             return __awaiter(this, void 0, void 0, function () {
                 var prk, decryptedCipher;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0:
                             if (!otKeyK) return [3 /*break*/, 2];
                             return [4 /*yield*/, KeyFactoryService.asKey(Object.assign(Object.assign({}, JSON.parse(keyExchange.otk.otKeyParams)), { k: otKeyK }))];
-                        case 1: return [2 /*return*/, _a.sent()];
+                        case 1: return [2 /*return*/, _b.sent()];
                         case 2:
                             if (!(keyExchange.otk.state === 'OTK_INITIATED' &&
                                 !keyExchange.isInitiator &&
@@ -8276,10 +8276,10 @@
                                     serializations: [JoseSerialization.COMPACT],
                                 })];
                         case 3:
-                            decryptedCipher = _a.sent();
+                            decryptedCipher = _b.sent();
                             if (!decryptedCipher.otKey) return [3 /*break*/, 5];
                             return [4 /*yield*/, KeyFactoryService.asKey(decryptedCipher.otKey)];
-                        case 4: return [2 /*return*/, _a.sent()];
+                        case 4: return [2 /*return*/, _b.sent()];
                         case 5: return [2 /*return*/, null];
                     }
                 });
@@ -8287,22 +8287,32 @@
         };
         KeyExchangeService.prototype.decryptOtk = function (keyExchange, otKeyK) {
             return __awaiter(this, void 0, void 0, function () {
-                var otKey, otk, _a, _b, _c, _d;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
+                var otKey, otk, _b, _c, _d, _e;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
                         case 0: return [4 /*yield*/, this.getOtKey(keyExchange, otKeyK)];
                         case 1:
-                            otKey = _e.sent();
+                            otKey = _f.sent();
                             otk = keyExchange.otk;
                             if (!(otKey && otk.otKeyCipher)) return [3 /*break*/, 3];
-                            _b = (_a = Object).assign;
-                            _c = [Object.assign({}, otk)];
-                            _d = { otKey: otKey };
+                            _c = (_b = Object).assign;
+                            _d = [Object.assign({}, otk)];
+                            _e = { otKey: otKey };
                             return [4 /*yield*/, this.encryptionService.decrypt(otKey, keyExchange.otk.otKeyCipher)];
                         case 2:
-                            otk = _b.apply(_a, _c.concat([(_d.otKeyCipherClearJson = _e.sent(), _d)]));
-                            _e.label = 3;
-                        case 3: return [2 /*return*/, Object.assign(Object.assign({}, keyExchange), { otk: otk })];
+                            otk = _c.apply(_b, _d.concat([(_e.otKeyCipherClearJson = _f.sent(), _e)]));
+                            return [3 /*break*/, 4];
+                        case 3:
+                            if (otk.otKeyCipher && !otKey) {
+                                // Log a warning when we have cipher data but couldn't obtain the key to decrypt it.
+                                // This typically happens when:
+                                // - The otKeyK (raw one-time key from URL hash) was not provided or was empty
+                                // - The responder doesn't have a responderPbkCipher (new user via invite)
+                                console.warn('KeyExchangeService: Unable to decrypt OTK cipher - one-time key not available. ' +
+                                    'otKeyK provided:', !!otKeyK, 'otKeyK value:', otKeyK ? '[present]' : '[empty/missing]');
+                            }
+                            _f.label = 4;
+                        case 4: return [2 /*return*/, Object.assign(Object.assign({}, keyExchange), { otk: otk })];
                     }
                 });
             });
@@ -8310,16 +8320,16 @@
         KeyExchangeService.prototype.decryptResponseCipher = function (otKey, otPrk, content) {
             return __awaiter(this, void 0, void 0, function () {
                 var error_1;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0:
-                            _a.trys.push([0, 2, , 3]);
+                            _b.trys.push([0, 2, , 3]);
                             return [4 /*yield*/, this.encryptionService.decrypt(otKey, content)];
                         case 1:
-                            content = _a.sent();
+                            content = _b.sent();
                             return [3 /*break*/, 3];
                         case 2:
-                            error_1 = _a.sent();
+                            error_1 = _b.sent();
                             if (error_1.message !== 'no key found') {
                                 throw error_1;
                             }
@@ -8327,44 +8337,44 @@
                         case 3: return [4 /*yield*/, this.encryptionService.decrypt(otPrk, content)];
                         case 4: 
                         // The Prk is single-use and only used to send information from the responder back to the initiator.
-                        return [2 /*return*/, _a.sent()];
+                        return [2 /*return*/, _b.sent()];
                     }
                 });
             });
         };
         KeyExchangeService.prototype.decryptKeyExchangeAsInitiator = function (keyExchange) {
             return __awaiter(this, void 0, void 0, function () {
-                var rootKey, initiatorRootKeyCipherClearJson, otKey, otk, _a, _b, _c, _d, _e, _f, _g;
-                return __generator(this, function (_h) {
-                    switch (_h.label) {
+                var rootKey, initiatorRootKeyCipherClearJson, otKey, otk, _b, _c, _d, _e, _f, _g, _h;
+                return __generator(this, function (_j) {
+                    switch (_j.label) {
                         case 0:
                             rootKey = this.keyService.currentRootKey;
                             return [4 /*yield*/, this.encryptionService.decrypt(rootKey.jwk, keyExchange.initiatorRootKeyCipher)];
                         case 1:
-                            initiatorRootKeyCipherClearJson = (_h.sent());
+                            initiatorRootKeyCipherClearJson = (_j.sent());
                             return [4 /*yield*/, KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.otKey)];
                         case 2:
-                            otKey = _h.sent();
+                            otKey = _j.sent();
                             keyExchange = Object.assign(Object.assign({}, keyExchange), { initiatorRootKeyCipherClearJson: initiatorRootKeyCipherClearJson });
                             otk = keyExchange.otk;
                             if (!otk.initiatorOneTimePbkCipher) return [3 /*break*/, 5];
-                            _b = (_a = Object).assign;
-                            _c = [Object.assign({}, otk)];
-                            _d = {};
-                            _e = this.decryptResponseCipher;
-                            _f = [otKey];
+                            _c = (_b = Object).assign;
+                            _d = [Object.assign({}, otk)];
+                            _e = {};
+                            _f = this.decryptResponseCipher;
+                            _g = [otKey];
                             return [4 /*yield*/, KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.oneTimePrk)];
-                        case 3: return [4 /*yield*/, _e.apply(this, _f.concat([_h.sent(), otk.initiatorOneTimePbkCipher]))];
+                        case 3: return [4 /*yield*/, _f.apply(this, _g.concat([_j.sent(), otk.initiatorOneTimePbkCipher]))];
                         case 4:
-                            otk = _b.apply(_a, _c.concat([(_d.initiatorOneTimePbkCipherClearJson = _h.sent(), _d)]));
-                            _h.label = 5;
+                            otk = _c.apply(_b, _d.concat([(_e.initiatorOneTimePbkCipherClearJson = _j.sent(), _e)]));
+                            _j.label = 5;
                         case 5:
                             if (!otk.otKeyCipher) return [3 /*break*/, 7];
-                            _g = otk;
+                            _h = otk;
                             return [4 /*yield*/, this.encryptionService.decrypt(otKey, otk.otKeyCipher)];
                         case 6:
-                            _g.otKeyCipherClearJson = _h.sent();
-                            _h.label = 7;
+                            _h.otKeyCipherClearJson = _j.sent();
+                            _j.label = 7;
                         case 7: return [2 /*return*/, Object.assign(Object.assign({}, keyExchange), { otk: otk })];
                     }
                 });
@@ -8372,14 +8382,14 @@
         };
         KeyExchangeService.prototype.decryptKeyExchangeAsResponder = function (keyExchange, otKeyK) {
             return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
+                return __generator(this, function (_b) {
                     return [2 /*return*/, this.decryptOtk(keyExchange, otKeyK)];
                 });
             });
         };
         KeyExchangeService.prototype.decryptKeyExchange = function (keyExchange, otKeyK) {
             return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
+                return __generator(this, function (_b) {
                     if (keyExchange.isInitiator) {
                         return [2 /*return*/, this.decryptKeyExchangeAsInitiator(keyExchange)];
                     }
@@ -8390,13 +8400,13 @@
                 });
             });
         };
-        KeyExchangeService.prototype.getKeyExchanges = function (_a) {
-            var _b = _a === void 0 ? {} : _a, state = _b.state;
+        KeyExchangeService.prototype.getKeyExchanges = function (_b) {
+            var _c = _b === void 0 ? {} : _b, state = _c.state;
             return __awaiter(this, void 0, void 0, function () {
                 var keyExchanges;
                 var _this = this;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0: return [4 /*yield*/, this.query({
                                 query: KeyExchangesQuery2,
                                 variables: {
@@ -8404,7 +8414,7 @@
                                 },
                             })];
                         case 1:
-                            keyExchanges = (_a.sent()).keyExchanges;
+                            keyExchanges = (_b.sent()).keyExchanges;
                             return [2 /*return*/, Promise.all(keyExchanges.edges.map(function (edge) { return _this.decryptKeyExchange(edge.node); }))];
                     }
                 });
@@ -8416,12 +8426,12 @@
          * @param otKeyK Is the raw one-time key (string). If the responder is explicitly specified at time of initiation, then
          *   it's possible to have the otKey wrapped by the public key of the responder. In which case, the otKeyK is not needed.
          */
-        KeyExchangeService.prototype.getKeyExchange = function (id, _a) {
-            var _b = _a === void 0 ? {} : _a, otKeyK = _b.otKeyK, token = _b.token;
+        KeyExchangeService.prototype.getKeyExchange = function (id, _b) {
+            var _c = _b === void 0 ? {} : _b, otKeyK = _c.otKeyK, token = _c.token;
             return __awaiter(this, void 0, void 0, function () {
                 var res;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0: return [4 /*yield*/, this.query({
                                 query: token ? KeyExchangeTokenQuery2 : KeyExchangeQuery2,
                                 variables: {
@@ -8431,7 +8441,7 @@
                                 includeKeyGraph: !token,
                             })];
                         case 1:
-                            res = _a.sent();
+                            res = _b.sent();
                             return [2 /*return*/, this.decryptKeyExchange(res.keyExchange, otKeyK)];
                     }
                 });
@@ -8439,7 +8449,7 @@
         };
         KeyExchangeService.prototype.getCurrentUserSharedKey = function (input) {
             return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
+                return __generator(this, function (_b) {
                     return [2 /*return*/, this.query({
                             query: CurrentUserSharedKeyQuery2,
                             variables: {
@@ -8480,38 +8490,38 @@
         KeyExchangeService.prototype.initiateOtk = function (input) {
             if (input === void 0) { input = {}; }
             return __awaiter(this, void 0, void 0, function () {
-                var _a;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                var _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
                         case 0:
-                            _a = this.mutate;
+                            _b = this.mutate;
                             return [4 /*yield*/, this.initiateOtkMutation(input)];
-                        case 1: return [2 /*return*/, _a.apply(this, [(_b.sent()).lrMutation])];
+                        case 1: return [2 /*return*/, _b.apply(this, [(_c.sent()).lrMutation])];
                     }
                 });
             });
         };
-        KeyExchangeService.prototype.initiateOtkMutation = function (_a) {
-            var _b = _a === void 0 ? {} : _a, message = _b.message, email = _b.email, contactCard = _b.contactCard, upgrade = _b.upgrade;
+        KeyExchangeService.prototype.initiateOtkMutation = function (_b) {
+            var _c = _b === void 0 ? {} : _b, message = _c.message, email = _c.email, contactCard = _c.contactCard, upgrade = _c.upgrade;
             return __awaiter(this, void 0, void 0, function () {
                 var otKey, nonce, initiatorOneTimePrk, initiatorPrk, initiatorSigPrk, initiatorPlainDataSig, initiator, plainOtKeyCipher, otKeyCipher, initiatorRootKeyCipherClearJson, rootKey, initiatorRootKeyCipher, otKeyK, lrMutation;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0: return [4 /*yield*/, this.keyFactory.createKey()];
                         case 1:
-                            otKey = _a.sent();
+                            otKey = _b.sent();
                             nonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);
                             return [4 /*yield*/, this.keyFactory.createPkcKey()];
                         case 2:
-                            initiatorOneTimePrk = _a.sent();
+                            initiatorOneTimePrk = _b.sent();
                             initiatorPrk = this.keyService.currentPxk;
                             initiatorSigPrk = this.keyService.currentSigPxk;
                             initiatorPlainDataSig = null;
                             if (!(contactCard && contactCard.ownerPlainDataJson)) return [3 /*break*/, 4];
                             return [4 /*yield*/, this.encryptionService.signToString(initiatorSigPrk.jwk, contactCard.ownerPlainDataJson)];
                         case 3:
-                            initiatorPlainDataSig = _a.sent();
-                            _a.label = 4;
+                            initiatorPlainDataSig = _b.sent();
+                            _b.label = 4;
                         case 4:
                             initiator = {
                                 message: message,
@@ -8530,7 +8540,7 @@
                             };
                             return [4 /*yield*/, this.keyGraph.encryptToString(otKey, plainOtKeyCipher)];
                         case 5:
-                            otKeyCipher = _a.sent();
+                            otKeyCipher = _b.sent();
                             initiatorRootKeyCipherClearJson = {
                                 nonce: nonce,
                                 oneTimePrk: initiatorOneTimePrk.toJSON(true),
@@ -8548,7 +8558,7 @@
                             rootKey = this.keyService.currentRootKey;
                             return [4 /*yield*/, this.keyGraph.encryptToString(rootKey.jwk, initiatorRootKeyCipherClearJson)];
                         case 6:
-                            initiatorRootKeyCipher = _a.sent();
+                            initiatorRootKeyCipher = _b.sent();
                             otKeyK = otKey.toJSON(true).k;
                             lrMutation = new LrMutation({
                                 mutation: InitiateKeyExchangeOtkMutation,
@@ -8579,44 +8589,52 @@
         KeyExchangeService.prototype.respondOtk = function (input) {
             return this.mutate(this.respondOtkMutation(input));
         };
-        KeyExchangeService.prototype.respondOtkMutation = function (_a) {
-            var keyExchangeId = _a.keyExchangeId, token = _a.token, decryptedOtk = _a.decryptedOtk, message = _a.message, initiatorContactCard = _a.initiatorContactCard, responderContactCard = _a.responderContactCard;
+        KeyExchangeService.prototype.respondOtkMutation = function (_b) {
+            var keyExchangeId = _b.keyExchangeId, token = _b.token, decryptedOtk = _b.decryptedOtk, message = _b.message, initiatorContactCard = _b.initiatorContactCard, responderContactCard = _b.responderContactCard;
+            var _a;
             return __awaiter(this, void 0, void 0, function () {
-                var rootKey, masterKey, sharedKey, mkSharedKey, rkWrappedSharedKey, mkWrappedMkSharedKey, initiatorOneTimePbk, initiatorPbk, initiatorSigPbk, responderPrk, responderSigPrk, signedInitiatorPbk, signedInitiatorSigPbk, initiatorOneTimePbkCipherClearJson, receivedCardInput, sharedCipherDataClearJson, receiverKey, ccSharedKey, sigPxk, _a, _b, _c, _d, _e, _f, _g, _h, sharedCipherData, _j, _k, _l, responderCardInput, ownerKey, ccSharedKey, sigPxk, _m, _o, _p, _q, _r, _s, _t, _u, sharedCipherData, _v, _w, _x, _y, _z, _0, initiatorOneTimePbkCipher;
-                return __generator(this, function (_1) {
-                    switch (_1.label) {
+                var rootKey, masterKey, sharedKey, mkSharedKey, rkWrappedSharedKey, mkWrappedMkSharedKey, initiatorOneTimePbk, initiatorPbk, initiatorSigPbk, responderPrk, responderSigPrk, signedInitiatorPbk, signedInitiatorSigPbk, initiatorOneTimePbkCipherClearJson, receivedCardInput, sharedCipherDataClearJson, receiverKey, ccSharedKey, sigPxk, _b, _c, _d, _e, _f, _g, _h, _j, sharedCipherData, _k, _l, _m, responderCardInput, ownerKey, ccSharedKey, sigPxk, _o, _p, _q, _r, _s, _t, _u, _v, sharedCipherData, _w, _x, _y, _z, _0, _1, initiatorOneTimePbkCipher;
+                return __generator(this, function (_2) {
+                    switch (_2.label) {
                         case 0:
+                            // Validate that the OTK was properly decrypted before proceeding.
+                            // This can fail if the one-time key (otKeyK) was not provided or was invalid,
+                            // which can happen if the invite URL hash fragment was lost (e.g., page refresh after hash removal).
+                            if (!((_a = decryptedOtk === null || decryptedOtk === void 0 ? void 0 : decryptedOtk.otKeyCipherClearJson) === null || _a === void 0 ? void 0 : _a.initiator)) {
+                                throw new Error('Failed to decrypt key exchange data. The invite link may be invalid or expired. ' +
+                                    'Please request a new invite from the sender.');
+                            }
                             rootKey = this.keyService.currentRootKey;
                             masterKey = this.keyService.currentMasterKey;
                             return [4 /*yield*/, this.keyFactory.createKey()];
                         case 1:
-                            sharedKey = _1.sent();
+                            sharedKey = _2.sent();
                             return [4 /*yield*/, this.keyFactory.createKey()];
                         case 2:
-                            mkSharedKey = _1.sent();
+                            mkSharedKey = _2.sent();
                             return [4 /*yield*/, this.encryptionService.encrypt(rootKey.jwk, sharedKey.toJSON(true))];
                         case 3:
-                            rkWrappedSharedKey = _1.sent();
+                            rkWrappedSharedKey = _2.sent();
                             return [4 /*yield*/, this.encryptionService.encrypt(masterKey.jwk, mkSharedKey.toJSON(true))];
                         case 4:
-                            mkWrappedMkSharedKey = _1.sent();
+                            mkWrappedMkSharedKey = _2.sent();
                             return [4 /*yield*/, KeyFactoryService.asKey(decryptedOtk.otKeyCipherClearJson.initiator.oneTimePbk)];
                         case 5:
-                            initiatorOneTimePbk = _1.sent();
+                            initiatorOneTimePbk = _2.sent();
                             return [4 /*yield*/, KeyFactoryService.asKey(decryptedOtk.otKeyCipherClearJson.initiator.pbk)];
                         case 6:
-                            initiatorPbk = _1.sent();
+                            initiatorPbk = _2.sent();
                             return [4 /*yield*/, KeyFactoryService.asKey(decryptedOtk.otKeyCipherClearJson.initiator.sigPbk)];
                         case 7:
-                            initiatorSigPbk = _1.sent();
+                            initiatorSigPbk = _2.sent();
                             responderPrk = this.keyService.currentPxk;
                             responderSigPrk = this.keyService.currentSigPxk;
                             return [4 /*yield*/, this.encryptionService.sign(responderSigPrk.jwk, initiatorPbk.toJSON())];
                         case 8:
-                            signedInitiatorPbk = _1.sent();
+                            signedInitiatorPbk = _2.sent();
                             return [4 /*yield*/, this.encryptionService.sign(responderSigPrk.jwk, initiatorSigPbk.toJSON())];
                         case 9:
-                            signedInitiatorSigPbk = _1.sent();
+                            signedInitiatorSigPbk = _2.sent();
                             initiatorOneTimePbkCipherClearJson = {
                                 nonce: decryptedOtk.otKeyCipherClearJson.nonce,
                                 sharedKey: sharedKey.toJSON(true),
@@ -8632,102 +8650,102 @@
                                 .sharedCipherDataClearJson;
                             return [4 /*yield*/, this.keyFactory.createKey()];
                         case 10:
-                            receiverKey = _1.sent();
+                            receiverKey = _2.sent();
                             return [4 /*yield*/, this.keyFactory.createKey()];
                         case 11:
-                            ccSharedKey = _1.sent();
+                            ccSharedKey = _2.sent();
                             sigPxk = this.keyService.currentSigPxk;
-                            _a = {};
-                            _c = (_b = JSON).stringify;
+                            _b = {};
+                            _d = (_c = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.encrypt(rootKey.jwk, receiverKey.toJSON(true))];
                         case 12:
-                            _a.receiverWrappedKey = _c.apply(_b, [_1.sent()]),
-                                _a.receiverWrappingKeyId = rootKey.id;
+                            _b.receiverWrappedKey = _d.apply(_c, [_2.sent()]),
+                                _b.receiverWrappingKeyId = rootKey.id;
                             if (!initiatorContactCard) return [3 /*break*/, 14];
-                            _f = (_e = JSON).stringify;
+                            _g = (_f = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.encrypt(receiverKey, initiatorContactCard.receiverCipherDataClearJson)];
                         case 13:
-                            _d = _f.apply(_e, [_1.sent()]);
+                            _e = _g.apply(_f, [_2.sent()]);
                             return [3 /*break*/, 15];
                         case 14:
-                            _d = '';
-                            _1.label = 15;
+                            _e = '';
+                            _2.label = 15;
                         case 15:
-                            _a.receiverCipherData = _d;
-                            _h = (_g = JSON).stringify;
+                            _b.receiverCipherData = _e;
+                            _j = (_h = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.encrypt(sharedKey, ccSharedKey.toJSON(true))];
                         case 16:
-                            receivedCardInput = (_a.sharedWrappedKey = _h.apply(_g, [_1.sent()]),
-                                _a);
+                            receivedCardInput = (_b.sharedWrappedKey = _j.apply(_h, [_2.sent()]),
+                                _b);
                             return [4 /*yield*/, this.encryptionService.encrypt(ccSharedKey, sharedCipherDataClearJson)];
                         case 17:
-                            sharedCipherData = _1.sent();
-                            _j = receivedCardInput;
-                            _l = (_k = JSON).stringify;
+                            sharedCipherData = _2.sent();
+                            _k = receivedCardInput;
+                            _m = (_l = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.sign(sigPxk.jwk, sharedCipherData)];
                         case 18:
-                            _j.sharedCipherDataSig = _l.apply(_k, [_1.sent()]);
+                            _k.sharedCipherDataSig = _m.apply(_l, [_2.sent()]);
                             receivedCardInput.sigPxkId = sigPxk.id;
                             initiatorOneTimePbkCipherClearJson.responder.contactCard = Object.assign(Object.assign({}, initiatorOneTimePbkCipherClearJson.responder.contactCard), { sharedCipherKey: ccSharedKey.toJSON(true) });
-                            _1.label = 19;
+                            _2.label = 19;
                         case 19:
                             if (!responderContactCard) return [3 /*break*/, 31];
                             return [4 /*yield*/, this.keyFactory.createKey()];
                         case 20:
-                            ownerKey = _1.sent();
+                            ownerKey = _2.sent();
                             return [4 /*yield*/, this.keyFactory.createKey()];
                         case 21:
-                            ccSharedKey = _1.sent();
+                            ccSharedKey = _2.sent();
                             sigPxk = this.keyService.currentSigPxk;
-                            _m = {};
-                            _p = (_o = JSON).stringify;
+                            _o = {};
+                            _q = (_p = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.encrypt(rootKey.jwk, ownerKey.toJSON(true))];
                         case 22:
-                            _m.ownerWrappedKey = _p.apply(_o, [_1.sent()]),
-                                _m.ownerWrappingKeyId = rootKey.id;
+                            _o.ownerWrappedKey = _q.apply(_p, [_2.sent()]),
+                                _o.ownerWrappingKeyId = rootKey.id;
                             if (!responderContactCard.ownerCipherDataClearJson) return [3 /*break*/, 24];
-                            _s = (_r = JSON).stringify;
+                            _t = (_s = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.encrypt(ownerKey, responderContactCard.ownerCipherDataClearJson)];
                         case 23:
-                            _q = _s.apply(_r, [_1.sent()]);
+                            _r = _t.apply(_s, [_2.sent()]);
                             return [3 /*break*/, 25];
                         case 24:
-                            _q = '';
-                            _1.label = 25;
+                            _r = '';
+                            _2.label = 25;
                         case 25:
-                            _m.ownerCipherData = _q;
-                            _u = (_t = JSON).stringify;
+                            _o.ownerCipherData = _r;
+                            _v = (_u = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.encrypt(sharedKey, ccSharedKey.toJSON(true))];
                         case 26:
-                            responderCardInput = (_m.sharedWrappedKey = _u.apply(_t, [_1.sent()]),
-                                _m);
+                            responderCardInput = (_o.sharedWrappedKey = _v.apply(_u, [_2.sent()]),
+                                _o);
                             return [4 /*yield*/, this.encryptionService.encrypt(ccSharedKey, responderContactCard.sharedCipherDataClearJson)];
                         case 27:
-                            sharedCipherData = _1.sent();
-                            _v = responderCardInput;
-                            _x = (_w = JSON).stringify;
+                            sharedCipherData = _2.sent();
+                            _w = responderCardInput;
+                            _y = (_x = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.sign(sigPxk.jwk, sharedCipherData)];
                         case 28:
-                            _v.sharedCipherDataSig = _x.apply(_w, [_1.sent()]);
+                            _w.sharedCipherDataSig = _y.apply(_x, [_2.sent()]);
                             responderCardInput.sigPxkId = sigPxk.id;
                             if (!responderContactCard.ownerPlainDataJson) return [3 /*break*/, 30];
-                            _y = responderCardInput;
-                            _0 = (_z = JSON).stringify;
+                            _z = responderCardInput;
+                            _1 = (_0 = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.sign(responderSigPrk.jwk, responderContactCard.ownerPlainDataJson)];
                         case 29:
-                            _y.ownerPlainDataSig = _0.apply(_z, [_1.sent()]);
-                            _1.label = 30;
+                            _z.ownerPlainDataSig = _1.apply(_0, [_2.sent()]);
+                            _2.label = 30;
                         case 30:
                             // Contact card info readable by the initiator
                             initiatorOneTimePbkCipherClearJson.responder.contactCard = Object.assign(Object.assign({}, initiatorOneTimePbkCipherClearJson.responder.contactCard), { sharedCipherDataClearJson: responderContactCard.sharedCipherDataClearJson });
-                            _1.label = 31;
+                            _2.label = 31;
                         case 31: return [4 /*yield*/, this.encryptionService.encrypt(initiatorOneTimePbk, initiatorOneTimePbkCipherClearJson)];
                         case 32:
-                            initiatorOneTimePbkCipher = _1.sent();
+                            initiatorOneTimePbkCipher = _2.sent();
                             return [4 /*yield*/, this.encryptionService.encrypt(decryptedOtk.otKey, initiatorOneTimePbkCipher)];
                         case 33:
                             // Encrypt with the otk again to keep use of asymmetric keys to a minimum.
-                            initiatorOneTimePbkCipher = _1.sent();
+                            initiatorOneTimePbkCipher = _2.sent();
                             return [2 /*return*/, new LrMutation({
                                     mutation: RespondKeyExchangeOtkMutation,
                                     variables: {
@@ -8760,26 +8778,26 @@
         KeyExchangeService.prototype.completeOtk = function (input) {
             return this.mutate(this.completeOtkMutation(input));
         };
-        KeyExchangeService.prototype.completeOtkMutation = function (_a) {
-            var keyExchangeId = _a.keyExchangeId, initiatorRootKeyCipher = _a.initiatorRootKeyCipher, initiatorOneTimePbkCipher = _a.initiatorOneTimePbkCipher, responderContactCard = _a.responderContactCard, initiatorContactCard = _a.initiatorContactCard;
+        KeyExchangeService.prototype.completeOtkMutation = function (_b) {
+            var keyExchangeId = _b.keyExchangeId, initiatorRootKeyCipher = _b.initiatorRootKeyCipher, initiatorOneTimePbkCipher = _b.initiatorOneTimePbkCipher, responderContactCard = _b.responderContactCard, initiatorContactCard = _b.initiatorContactCard;
             return __awaiter(this, void 0, void 0, function () {
-                var rootKey, masterKey, initiatorRootKeyCipherClearJson, plainInitiatorOneTimePbkCipher, _a, _b, initiatorSigPrk, responderSigPbk, responderPbk, signedResponderPbk, signedResponderSigPbk, sharedKey, rkWrappedSharedKey, mkSharedKey, mkWrappedMkSharedKey, responderContactCardCipherInput, receiverKey, _c, _d, _e, _f, _g, initiatorContactCardCipherInput, initiatorContactCardSharedCipherInput, initiatorContactCardFromInit, ownerKey, sharedCipherKey, ownerWrappedKey, _h, _j, ownerCipherDataClearJson, ownerCipherData, _k, sharedCipherData, _l, _m, _o;
-                return __generator(this, function (_p) {
-                    switch (_p.label) {
+                var rootKey, masterKey, initiatorRootKeyCipherClearJson, plainInitiatorOneTimePbkCipher, _b, _c, initiatorSigPrk, responderSigPbk, responderPbk, signedResponderPbk, signedResponderSigPbk, sharedKey, rkWrappedSharedKey, mkSharedKey, mkWrappedMkSharedKey, responderContactCardCipherInput, receiverKey, _d, _e, _f, _g, _h, initiatorContactCardCipherInput, initiatorContactCardSharedCipherInput, initiatorContactCardFromInit, ownerKey, sharedCipherKey, ownerWrappedKey, _j, _k, ownerCipherDataClearJson, ownerCipherData, _l, sharedCipherData, _m, _o, _p;
+                return __generator(this, function (_q) {
+                    switch (_q.label) {
                         case 0:
                             rootKey = this.keyService.currentRootKey;
                             masterKey = this.keyService.currentMasterKey;
                             return [4 /*yield*/, this.encryptionService.decrypt(rootKey.jwk, initiatorRootKeyCipher)];
                         case 1:
-                            initiatorRootKeyCipherClearJson = (_p.sent());
-                            _a = this.decryptResponseCipher;
+                            initiatorRootKeyCipherClearJson = (_q.sent());
+                            _b = this.decryptResponseCipher;
                             return [4 /*yield*/, KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.otKey)];
                         case 2:
-                            _b = [_p.sent()];
+                            _c = [_q.sent()];
                             return [4 /*yield*/, KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.oneTimePrk)];
-                        case 3: return [4 /*yield*/, _a.apply(this, _b.concat([_p.sent(), initiatorOneTimePbkCipher]))];
+                        case 3: return [4 /*yield*/, _b.apply(this, _c.concat([_q.sent(), initiatorOneTimePbkCipher]))];
                         case 4:
-                            plainInitiatorOneTimePbkCipher = _p.sent();
+                            plainInitiatorOneTimePbkCipher = _q.sent();
                             // Check the nonce match to ensure the responder was the one holding the OTK
                             if (initiatorRootKeyCipherClearJson.nonce !==
                                 plainInitiatorOneTimePbkCipher.nonce) {
@@ -8788,69 +8806,69 @@
                             initiatorSigPrk = this.keyService.currentSigPxk;
                             return [4 /*yield*/, KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.responder.sigPbk)];
                         case 5:
-                            responderSigPbk = _p.sent();
+                            responderSigPbk = _q.sent();
                             return [4 /*yield*/, KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.responder.pbk)];
                         case 6:
-                            responderPbk = _p.sent();
+                            responderPbk = _q.sent();
                             return [4 /*yield*/, this.encryptionService.sign(initiatorSigPrk.jwk, responderPbk.toJSON())];
                         case 7:
-                            signedResponderPbk = _p.sent();
+                            signedResponderPbk = _q.sent();
                             return [4 /*yield*/, this.encryptionService.sign(initiatorSigPrk.jwk, responderSigPbk.toJSON())];
                         case 8:
-                            signedResponderSigPbk = _p.sent();
+                            signedResponderSigPbk = _q.sent();
                             return [4 /*yield*/, KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.sharedKey)];
                         case 9:
-                            sharedKey = _p.sent();
+                            sharedKey = _q.sent();
                             return [4 /*yield*/, this.encryptionService.encrypt(rootKey.jwk, sharedKey.toJSON(true))];
                         case 10:
-                            rkWrappedSharedKey = _p.sent();
+                            rkWrappedSharedKey = _q.sent();
                             return [4 /*yield*/, KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.mkSharedKey)];
                         case 11:
-                            mkSharedKey = _p.sent();
+                            mkSharedKey = _q.sent();
                             return [4 /*yield*/, this.encryptionService.encrypt(masterKey.jwk, mkSharedKey.toJSON(true))];
                         case 12:
-                            mkWrappedMkSharedKey = _p.sent();
+                            mkWrappedMkSharedKey = _q.sent();
                             if (!responderContactCard) return [3 /*break*/, 16];
                             return [4 /*yield*/, this.keyFactory.createKey()];
                         case 13:
-                            receiverKey = _p.sent();
-                            _c = {};
-                            _e = (_d = JSON).stringify;
+                            receiverKey = _q.sent();
+                            _d = {};
+                            _f = (_e = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.encrypt(rootKey.jwk, receiverKey.toJSON(true))];
                         case 14:
-                            _c.receiverWrappedKey = _e.apply(_d, [_p.sent()]),
-                                _c.receiverWrappingKeyId = rootKey.id;
-                            _g = (_f = JSON).stringify;
+                            _d.receiverWrappedKey = _f.apply(_e, [_q.sent()]),
+                                _d.receiverWrappingKeyId = rootKey.id;
+                            _h = (_g = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.encrypt(receiverKey, responderContactCard.receiverCipherDataClearJson)];
                         case 15:
-                            responderContactCardCipherInput = (_c.receiverCipherData = _g.apply(_f, [_p.sent()]),
-                                _c);
-                            _p.label = 16;
+                            responderContactCardCipherInput = (_d.receiverCipherData = _h.apply(_g, [_q.sent()]),
+                                _d);
+                            _q.label = 16;
                         case 16:
                             if (!initiatorRootKeyCipherClearJson.initiatorContactCard) return [3 /*break*/, 25];
                             initiatorContactCardFromInit = initiatorRootKeyCipherClearJson.initiatorContactCard;
                             return [4 /*yield*/, this.keyFactory.createKey()];
                         case 17:
-                            ownerKey = _p.sent();
+                            ownerKey = _q.sent();
                             return [4 /*yield*/, KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.responder.contactCard.sharedCipherKey)];
                         case 18:
-                            sharedCipherKey = _p.sent();
-                            _j = (_h = JSON).stringify;
+                            sharedCipherKey = _q.sent();
+                            _k = (_j = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.encrypt(rootKey.jwk, ownerKey.toJSON(true))];
                         case 19:
-                            ownerWrappedKey = _j.apply(_h, [_p.sent()]);
+                            ownerWrappedKey = _k.apply(_j, [_q.sent()]);
                             ownerCipherDataClearJson = (initiatorContactCard === null || initiatorContactCard === void 0 ? void 0 : initiatorContactCard.ownerCipherDataClearJson) ||
                                 initiatorContactCardFromInit.ownerCipherDataClearJson;
                             if (!ownerCipherDataClearJson) return [3 /*break*/, 21];
                             return [4 /*yield*/, this.keyGraph.encryptToString(ownerKey, ownerCipherDataClearJson)];
                         case 20:
-                            _k = _p.sent();
+                            _l = _q.sent();
                             return [3 /*break*/, 22];
                         case 21:
-                            _k = '';
-                            _p.label = 22;
+                            _l = '';
+                            _q.label = 22;
                         case 22:
-                            ownerCipherData = _k;
+                            ownerCipherData = _l;
                             initiatorContactCardCipherInput = {
                                 ownerWrappedKey: ownerWrappedKey,
                                 ownerWrappingKeyId: rootKey.id,
@@ -8861,14 +8879,14 @@
                             };
                             return [4 /*yield*/, this.encryptionService.encrypt(sharedCipherKey, initiatorContactCardFromInit.sharedCipherDataClearJson)];
                         case 23:
-                            sharedCipherData = _p.sent();
-                            _l = initiatorContactCardSharedCipherInput;
-                            _o = (_m = JSON).stringify;
+                            sharedCipherData = _q.sent();
+                            _m = initiatorContactCardSharedCipherInput;
+                            _p = (_o = JSON).stringify;
                             return [4 /*yield*/, this.encryptionService.sign(initiatorSigPrk.jwk, sharedCipherData)];
                         case 24:
-                            _l.sharedCipherDataSig =
-                                _o.apply(_m, [_p.sent()]);
-                            _p.label = 25;
+                            _m.sharedCipherDataSig =
+                                _p.apply(_o, [_q.sent()]);
+                            _q.label = 25;
                         case 25: 
                         // TODO ideally we update the shared data in the contact card sent to the responder as well since that
                         // CC was created by the responder.