@docknetwork/wallet-sdk-relay-service 1.7.0 → 1.9.0

package/lib/didcomm.mjs

@@ -1,4 +1,4 @@
-import { _ as _asyncToGenerator, a as _regeneratorRuntime, b as _toConsumableArray, c as _objectSpread2 } from './_rollupPluginBabelHelpers-ea876378.js';
+import { _ as _asyncToGenerator, a as _regenerator, b as _toConsumableArray, c as _objectSpread2 } from './_rollupPluginBabelHelpers-85237803.js';
 import { X25519KeyAgreementKey2020 } from '@digitalbazaar/x25519-key-agreement-key-2020';
 import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
 import { Cipher } from '@docknetwork/minimal-cipher';
@@ -28,23 +28,20 @@ function getKeydocFromDID(_x) {
   return _getKeydocFromDID.apply(this, arguments);
 }
 function _getKeydocFromDID() {
-  _getKeydocFromDID = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(didUrl) {
+  _getKeydocFromDID = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(didUrl) {
     var didDocument, possibleKeys, keyDoc;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
         case 0:
-          _context.next = 2;
+          _context.n = 1;
           return blockchainService.resolver.resolve(didUrl);
-        case 2:
-          didDocument = _context.sent;
+        case 1:
+          didDocument = _context.v;
           possibleKeys = [].concat(_toConsumableArray(potentialToArray(didDocument.verificationMethod)), _toConsumableArray(potentialToArray(didDocument.keyAgreement)), _toConsumableArray(potentialToArray(didDocument.publicKey)));
           keyDoc = possibleKeys.filter(function (key) {
             return key.id === didUrl;
           })[0];
-          return _context.abrupt("return", keyDoc);
-        case 6:
-        case "end":
-          return _context.stop();
+          return _context.a(2, keyDoc);
       }
     }, _callee);
   }));
@@ -58,29 +55,26 @@ function defaultKaKResolver(_x2) {
   return _defaultKaKResolver.apply(this, arguments);
 }
 function _defaultKaKResolver() {
-  _defaultKaKResolver = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(keyId) {
+  _defaultKaKResolver = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(keyId) {
     var keyIdStr, keyDoc;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
         case 0:
           keyIdStr = keyId.id || keyId;
-          _context2.next = 3;
+          _context2.n = 1;
           return getAgreementKeydocFromDID(keyIdStr);
-        case 3:
-          keyDoc = _context2.sent;
+        case 1:
+          keyDoc = _context2.v;
           if (keyDoc) {
-            _context2.next = 6;
+            _context2.n = 2;
             break;
           }
           throw new Error("Cannot find key document with ID: ".concat(keyIdStr));
-        case 6:
-          _context2.next = 8;
+        case 2:
+          _context2.n = 3;
           return getKaKInstanceFromDocument(keyDoc);
-        case 8:
-          return _context2.abrupt("return", _context2.sent);
-        case 9:
-        case "end":
-          return _context2.stop();
+        case 3:
+          return _context2.a(2, _context2.v);
       }
     }, _callee2);
   }));
@@ -90,31 +84,28 @@ function defaultVerificationKeyResolver(_x3) {
   return _defaultVerificationKeyResolver.apply(this, arguments);
 }
 function _defaultVerificationKeyResolver() {
-  _defaultVerificationKeyResolver = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(keyId) {
+  _defaultVerificationKeyResolver = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(keyId) {
     var keyIdStr, keyDoc;
-    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-      while (1) switch (_context3.prev = _context3.next) {
+    return _regenerator().w(function (_context3) {
+      while (1) switch (_context3.n) {
         case 0:
           keyIdStr = keyId.id || keyId;
-          _context3.next = 3;
+          _context3.n = 1;
           return getKeydocFromDID(keyIdStr);
-        case 3:
-          keyDoc = _context3.sent;
+        case 1:
+          keyDoc = _context3.v;
           if (keyDoc) {
-            _context3.next = 6;
+            _context3.n = 2;
             break;
           }
           throw new Error("Cannot find key document with ID: ".concat(keyIdStr));
-        case 6:
-          _context3.next = 8;
+        case 2:
+          _context3.n = 3;
           return Ed25519VerificationKey2020.from(_objectSpread2(_objectSpread2({}, keyDoc), {}, {
             keyPair: keyDoc
           }));
-        case 8:
-          return _context3.abrupt("return", _context3.sent);
-        case 9:
-        case "end":
-          return _context3.stop();
+        case 3:
+          return _context3.a(2, _context3.v);
       }
     }, _callee3);
   }));
@@ -124,7 +115,7 @@ function didcommCreateSignedJWT(_x4, _x5) {
   return _didcommCreateSignedJWT.apply(this, arguments);
 }
 function _didcommCreateSignedJWT() {
-  _didcommCreateSignedJWT = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(payload, privateKeyDoc) {
+  _didcommCreateSignedJWT = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(payload, privateKeyDoc) {
     var generateJWK,
       privateKey,
       _privateKey$signer,
@@ -138,16 +129,16 @@ function _didcommCreateSignedJWT() {
       signPayload,
       signature,
       _args4 = arguments;
-    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-      while (1) switch (_context4.prev = _context4.next) {
+    return _regenerator().w(function (_context4) {
+      while (1) switch (_context4.n) {
         case 0:
           generateJWK = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : false;
-          _context4.next = 3;
+          _context4.n = 1;
           return Ed25519VerificationKey2020.from(_objectSpread2(_objectSpread2({}, privateKeyDoc), {}, {
             keyPair: privateKeyDoc
           }));
-        case 3:
-          privateKey = _context4.sent;
+        case 1:
+          privateKey = _context4.v;
           _privateKey$signer = privateKey.signer(), sign = _privateKey$signer.sign;
           header = {
             alg: 'EdDSA',
@@ -161,16 +152,13 @@ function _didcommCreateSignedJWT() {
           payloadBase64URL = base64url(JSON.stringify(newPayload));
           headerAndPayloadBase64URL = "".concat(headerBase64URL, ".").concat(payloadBase64URL);
           signPayload = Buffer.from(headerAndPayloadBase64URL);
-          _context4.next = 14;
+          _context4.n = 2;
           return sign({
             data: signPayload
           });
-        case 14:
-          signature = _context4.sent;
-          return _context4.abrupt("return", "".concat(headerAndPayloadBase64URL, ".").concat(base64url.encode(signature)));
-        case 16:
-        case "end":
-          return _context4.stop();
+        case 2:
+          signature = _context4.v;
+          return _context4.a(2, "".concat(headerAndPayloadBase64URL, ".").concat(base64url.encode(signature)));
       }
     }, _callee4);
   }));
@@ -180,136 +168,126 @@ function didcommDecodeSignedJWT(_x6, _x7) {
   return _didcommDecodeSignedJWT.apply(this, arguments);
 }
 function _didcommDecodeSignedJWT() {
-  _didcommDecodeSignedJWT = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(jwt, keyResolver) {
+  _didcommDecodeSignedJWT = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(jwt, keyResolver) {
     var resolveKey, jwtSplit, header, alg, keyId, publicKey, _publicKey$verifier, verify, signature, signPayload, isVerified, body;
-    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-      while (1) switch (_context5.prev = _context5.next) {
+    return _regenerator().w(function (_context5) {
+      while (1) switch (_context5.n) {
         case 0:
           resolveKey = keyResolver || defaultVerificationKeyResolver;
           jwtSplit = jwt.split('.').map(function (s) {
             return s.trim();
           });
           if (!(jwtSplit.length !== 3)) {
-            _context5.next = 4;
+            _context5.n = 1;
             break;
           }
           throw new Error("Malformed JWT, got split length: ".concat(jwtSplit.length));
-        case 4:
+        case 1:
           header = JSON.parse(base64url.decode(jwtSplit[0]));
           alg = header.alg, keyId = header.kid;
           if (!(!alg || !keyId)) {
-            _context5.next = 8;
+            _context5.n = 2;
             break;
           }
           throw new Error('Malformed JWT header, expected alg and kid');
-        case 8:
-          _context5.next = 10;
+        case 2:
+          _context5.n = 3;
           return resolveKey(keyId);
-        case 10:
-          publicKey = _context5.sent;
+        case 3:
+          publicKey = _context5.v;
           _publicKey$verifier = publicKey.verifier(), verify = _publicKey$verifier.verify;
           signature = decodeBase64Url(jwtSplit[2]);
           signPayload = Buffer.from("".concat(jwtSplit[0], ".").concat(jwtSplit[1]));
-          _context5.next = 16;
+          _context5.n = 4;
           return verify({
             data: signPayload,
             signature: signature
           });
-        case 16:
-          isVerified = _context5.sent;
+        case 4:
+          isVerified = _context5.v;
           if (isVerified) {
-            _context5.next = 19;
+            _context5.n = 5;
             break;
           }
           throw new Error('JWT cannot be verified');
-        case 19:
+        case 5:
           body = JSON.parse(base64url.decode(jwtSplit[1]));
-          return _context5.abrupt("return", body);
-        case 21:
-        case "end":
-          return _context5.stop();
+          return _context5.a(2, body);
       }
     }, _callee5);
   }));
   return _didcommDecodeSignedJWT.apply(this, arguments);
 }
-function didcommEncrypt(_x8, _x9, _x10, _x11) {
+function didcommEncrypt(_x8, _x9, _x0, _x1) {
   return _didcommEncrypt.apply(this, arguments);
 }
 function _didcommEncrypt() {
-  _didcommEncrypt = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(obj, recipients, keyResolver, senderKey) {
+  _didcommEncrypt = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(obj, recipients, keyResolver, senderKey) {
     var keyAgreementKey, encryptedJWE;
-    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
-      while (1) switch (_context6.prev = _context6.next) {
+    return _regenerator().w(function (_context6) {
+      while (1) switch (_context6.n) {
         case 0:
           // If ed25519 is supplied, derive X25519 from it
           keyAgreementKey = senderKey;
           if (!(senderKey.type !== 'X25519KeyAgreementKey2020')) {
-            _context6.next = 5;
+            _context6.n = 2;
             break;
           }
-          _context6.next = 4;
+          _context6.n = 1;
           return getDerivedAgreementKey(senderKey);
-        case 4:
-          keyAgreementKey = _context6.sent;
-        case 5:
-          _context6.next = 7;
+        case 1:
+          keyAgreementKey = _context6.v;
+        case 2:
+          _context6.n = 3;
           return cipher.encryptObject({
             obj: obj,
             recipients: recipients,
             keyResolver: keyResolver || defaultKaKResolver,
             keyAgreementKey: keyAgreementKey
           });
-        case 7:
-          encryptedJWE = _context6.sent;
-          return _context6.abrupt("return", _objectSpread2({
+        case 3:
+          encryptedJWE = _context6.v;
+          return _context6.a(2, _objectSpread2({
             typ: 'application/didcomm-encrypted+json'
           }, encryptedJWE));
-        case 9:
-        case "end":
-          return _context6.stop();
       }
     }, _callee6);
   }));
   return _didcommEncrypt.apply(this, arguments);
 }
-function didcommDecrypt(_x12, _x13, _x14) {
+function didcommDecrypt(_x10, _x11, _x12) {
   return _didcommDecrypt.apply(this, arguments);
 }
 function _didcommDecrypt() {
-  _didcommDecrypt = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(jwe, keyAgreementKey, keyResolver) {
-    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
-      while (1) switch (_context7.prev = _context7.next) {
+  _didcommDecrypt = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(jwe, keyAgreementKey, keyResolver) {
+    return _regenerator().w(function (_context7) {
+      while (1) switch (_context7.n) {
         case 0:
-          return _context7.abrupt("return", cipher.decryptObject({
+          return _context7.a(2, cipher.decryptObject({
             jwe: jwe,
             keyAgreementKey: keyAgreementKey,
             keyResolver: keyResolver || defaultKaKResolver
           }));
-        case 1:
-        case "end":
-          return _context7.stop();
       }
     }, _callee7);
   }));
   return _didcommDecrypt.apply(this, arguments);
 }
-function didcommSendMessage(_x15, _x16) {
+function didcommSendMessage(_x13, _x14) {
   return _didcommSendMessage.apply(this, arguments);
 }
 function _didcommSendMessage() {
-  _didcommSendMessage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(to, message) {
-    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
-      while (1) switch (_context8.prev = _context8.next) {
+  _didcommSendMessage = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(to, message) {
+    return _regenerator().w(function (_context8) {
+      while (1) switch (_context8.n) {
         case 0:
           if (!(!message.typ || !message.typ.startsWith('application/didcomm'))) {
-            _context8.next = 2;
+            _context8.n = 1;
             break;
           }
           throw new Error('Only DIDComm messages can be sent with this service');
-        case 2:
-        case "end":
-          return _context8.stop();
+        case 1:
+          return _context8.a(2);
       }
     }, _callee8);
   }));
@@ -324,69 +302,68 @@ function isDerivableKey(keyDoc) {
 function getDIDKeydocsFromDIDDocument(didDocument) {
   return [].concat(_toConsumableArray(potentialToArray(didDocument.verificationMethod)), _toConsumableArray(potentialToArray(didDocument.keyAgreement)), _toConsumableArray(potentialToArray(didDocument.publicKey)));
 }
-function getAgreementKeydocFromDID(_x17) {
+function getAgreementKeydocFromDID(_x15) {
   return _getAgreementKeydocFromDID.apply(this, arguments);
 }
 function _getAgreementKeydocFromDID() {
-  _getAgreementKeydocFromDID = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(did) {
+  _getAgreementKeydocFromDID = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(did) {
     var isDIDUrl, didDocument, keyAgreements, foundDoc, firstKeyAgreement, publicKeys, derivableKey;
-    return _regeneratorRuntime().wrap(function _callee9$(_context9) {
-      while (1) switch (_context9.prev = _context9.next) {
+    return _regenerator().w(function (_context9) {
+      while (1) switch (_context9.n) {
         case 0:
           if (did) {
-            _context9.next = 2;
+            _context9.n = 1;
             break;
           }
-          return _context9.abrupt("return", undefined);
-        case 2:
+          return _context9.a(2, undefined);
+        case 1:
           if (!did.startsWith('did:polygon')) {
-            _context9.next = 4;
+            _context9.n = 2;
             break;
           }
           throw new Error('PolygonID DIDs cannot be used for DIDComm purposes');
-        case 4:
+        case 2:
           // Resolve actual DID document and get key agreement keys
           isDIDUrl = did.indexOf('#') !== -1;
-          _context9.next = 7;
+          _context9.n = 3;
           return blockchainService.resolver.resolve(did);
-        case 7:
-          didDocument = _context9.sent;
+        case 3:
+          didDocument = _context9.v;
           keyAgreements = didDocument.keyAgreement ? Array.isArray(didDocument.keyAgreement) ? didDocument.keyAgreement : [didDocument.keyAgreement] : []; // User supplied full URL, use that if possible
           // if not it may still require derivation to be valid (such as dock DIDs)
           if (!isDIDUrl) {
-            _context9.next = 13;
+            _context9.n = 4;
             break;
           }
           foundDoc = keyAgreements.filter(function (keyDoc) {
             return keyDoc.id === did && isValidKeyAgreementDoc(keyDoc);
           })[0];
           if (!foundDoc) {
-            _context9.next = 13;
+            _context9.n = 4;
             break;
           }
-          return _context9.abrupt("return", foundDoc);
-        case 13:
+          return _context9.a(2, foundDoc);
+        case 4:
           // User supplied DID, find first supported keyagreement document
           firstKeyAgreement = keyAgreements.filter(isValidKeyAgreementDoc)[0];
           if (!firstKeyAgreement) {
-            _context9.next = 16;
+            _context9.n = 5;
             break;
           }
-          return _context9.abrupt("return", firstKeyAgreement);
-        case 16:
+          return _context9.a(2, firstKeyAgreement);
+        case 5:
           // No valid key agreement found on resolution, lets derive one from a ED25519 key if we can
           publicKeys = getDIDKeydocsFromDIDDocument(didDocument); // See if DID document has any derivable keys
           derivableKey = publicKeys.filter(isDerivableKey)[0];
           if (!derivableKey) {
-            _context9.next = 20;
+            _context9.n = 6;
             break;
           }
-          return _context9.abrupt("return", getDerivedAgreementKey(derivableKey));
-        case 20:
+          return _context9.a(2, getDerivedAgreementKey(derivableKey));
+        case 6:
           throw new Error("Unable to find or derive X25519 key agreement for DID: ".concat(did));
-        case 21:
-        case "end":
-          return _context9.stop();
+        case 7:
+          return _context9.a(2);
       }
     }, _callee9);
   }));
@@ -401,21 +378,21 @@ function encodeMbKey(header, key) {
   mbKey.set(key, header.length);
   return MULTIBASE_BASE58BTC_HEADER + bs58.encode(mbKey);
 }
-function getDerivedAgreementKey(_x18) {
+function getDerivedAgreementKey(_x16) {
   return _getDerivedAgreementKey.apply(this, arguments);
 }
 function _getDerivedAgreementKey() {
-  _getDerivedAgreementKey = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(derivableKey) {
+  _getDerivedAgreementKey = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0(derivableKey) {
     var publicKeyMultibase, privateKeyMultibase, derivedKeyAgreement;
-    return _regeneratorRuntime().wrap(function _callee10$(_context10) {
-      while (1) switch (_context10.prev = _context10.next) {
+    return _regenerator().w(function (_context0) {
+      while (1) switch (_context0.n) {
         case 0:
           if (isDerivableKey(derivableKey)) {
-            _context10.next = 2;
+            _context0.n = 1;
             break;
           }
           throw new Error("Cannot derive X25519 KAK from type: ".concat(derivableKey.type));
-        case 2:
+        case 1:
           publicKeyMultibase = derivableKey.publicKeyBase58 ? encodeMbKey(MULTICODEC_ED25519_PUB_HEADER, bs58.decode(derivableKey.publicKeyBase58)) : derivableKey.publicKeyMultibase;
           privateKeyMultibase = (derivableKey.privateKeyBase58 ? encodeMbKey(MULTICODEC_ED25519_PRIV_HEADER, bs58.decode(derivableKey.privateKeyBase58)) : undefined) || derivableKey.privateKeyMultibase; // Convert ed25519 2020 verification key into a key agreement key
           derivedKeyAgreement = X25519KeyAgreementKey2020.fromEd25519VerificationKey2020({
@@ -425,38 +402,32 @@ function _getDerivedAgreementKey() {
               controller: derivableKey.controller
             }
           });
-          return _context10.abrupt("return", derivedKeyAgreement);
-        case 6:
-        case "end":
-          return _context10.stop();
+          return _context0.a(2, derivedKeyAgreement);
       }
-    }, _callee10);
+    }, _callee0);
   }));
   return _getDerivedAgreementKey.apply(this, arguments);
 }
-function getKaKInstanceFromDocument(_x19) {
+function getKaKInstanceFromDocument(_x17) {
   return _getKaKInstanceFromDocument.apply(this, arguments);
 }
 function _getKaKInstanceFromDocument() {
-  _getKaKInstanceFromDocument = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(keyDoc) {
-    return _regeneratorRuntime().wrap(function _callee11$(_context11) {
-      while (1) switch (_context11.prev = _context11.next) {
+  _getKaKInstanceFromDocument = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1(keyDoc) {
+    return _regenerator().w(function (_context1) {
+      while (1) switch (_context1.n) {
         case 0:
           if (isValidKeyAgreementDoc(keyDoc)) {
-            _context11.next = 2;
+            _context1.n = 1;
             break;
           }
           throw new Error("Invalid key document type for key agreement key: ".concat(keyDoc.type));
-        case 2:
-          _context11.next = 4;
+        case 1:
+          _context1.n = 2;
           return X25519KeyAgreementKey2020.from(keyDoc);
-        case 4:
-          return _context11.abrupt("return", _context11.sent);
-        case 5:
-        case "end":
-          return _context11.stop();
+        case 2:
+          return _context1.a(2, _context1.v);
       }
-    }, _callee11);
+    }, _callee1);
   }));
   return _getKaKInstanceFromDocument.apply(this, arguments);
 }
@@ -490,95 +461,91 @@ function formatPayloadToDIDComm(to, msgType, from, body, replyUrl, replyTo) {
   }
   return msg;
 }
-function didcommCreateEncrypted(_x20) {
+function didcommCreateEncrypted(_x18) {
   return _didcommCreateEncrypted.apply(this, arguments);
 }
 function _didcommCreateEncrypted() {
-  _didcommCreateEncrypted = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(_ref) {
-    var senderDid, _ref$recipientDids, recipientDids, payload, type, keyAgreementKey, algorithm, recipientKeyDocuments, recipients, keyResolver, didcommMessage, jweDoc;
-    return _regeneratorRuntime().wrap(function _callee13$(_context13) {
-      while (1) switch (_context13.prev = _context13.next) {
+  _didcommCreateEncrypted = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee11(_ref) {
+    var senderDid, _ref$recipientDids, recipientDids, payload, type, keyAgreementKey, algorithm, recipientKeyDocuments, recipients, keyResolver, didcommMessage, jweDoc, _t;
+    return _regenerator().w(function (_context11) {
+      while (1) switch (_context11.p = _context11.n) {
         case 0:
           senderDid = _ref.senderDid, _ref$recipientDids = _ref.recipientDids, recipientDids = _ref$recipientDids === void 0 ? [] : _ref$recipientDids, payload = _ref.payload, type = _ref.type, keyAgreementKey = _ref.keyAgreementKey, algorithm = _ref.algorithm;
           if (payload) {
-            _context13.next = 3;
+            _context11.n = 1;
             break;
           }
           throw new Error('Requires payload to create encrypted didcomm message');
-        case 3:
+        case 1:
           if (!(recipientDids.length === 0)) {
-            _context13.next = 5;
+            _context11.n = 2;
             break;
           }
           throw new Error('Must supply atleast 1 recipient DID');
-        case 5:
+        case 2:
           if (isValidDID(senderDid)) {
-            _context13.next = 7;
+            _context11.n = 3;
             break;
           }
           throw new Error('Sender DID must be a valid DID');
-        case 7:
+        case 3:
           if (recipientDids.every(isValidDID)) {
-            _context13.next = 9;
+            _context11.n = 4;
             break;
           }
           throw new Error('Recipient DID is invalid');
-        case 9:
-          _context13.next = 11;
+        case 4:
+          _context11.n = 5;
           return Promise.all(recipientDids.map(getAgreementKeydocFromDID));
-        case 11:
-          recipientKeyDocuments = _context13.sent;
+        case 5:
+          recipientKeyDocuments = _context11.v;
           recipients = recipientKeyDocuments.map(function (keyDoc) {
             return getJWERecipientFromDocument(keyDoc, algorithm);
           });
           keyResolver = /*#__PURE__*/function () {
-            var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(keyId) {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10(keyId) {
               var keyIdStr, keyDoc, result;
-              return _regeneratorRuntime().wrap(function _callee12$(_context12) {
-                while (1) switch (_context12.prev = _context12.next) {
+              return _regenerator().w(function (_context10) {
+                while (1) switch (_context10.n) {
                   case 0:
                     keyIdStr = keyId.id || keyId;
                     keyDoc = recipientKeyDocuments.filter(function (k) {
                       return k.id === keyIdStr;
                     })[0];
                     if (keyDoc) {
-                      _context12.next = 4;
+                      _context10.n = 1;
                       break;
                     }
                     throw new Error("Cannot find key document with ID: ".concat(keyIdStr));
-                  case 4:
-                    _context12.next = 6;
+                  case 1:
+                    _context10.n = 2;
                     return getKaKInstanceFromDocument(keyDoc);
-                  case 6:
-                    result = _context12.sent;
-                    return _context12.abrupt("return", result);
-                  case 8:
-                  case "end":
-                    return _context12.stop();
+                  case 2:
+                    result = _context10.v;
+                    return _context10.a(2, result);
                 }
-              }, _callee12);
+              }, _callee10);
             }));
-            return function keyResolver(_x21) {
+            return function keyResolver(_x19) {
               return _ref2.apply(this, arguments);
             };
           }();
           didcommMessage = formatPayloadToDIDComm(recipientDids, type, senderDid, payload);
-          _context13.prev = 15;
-          _context13.next = 18;
+          _context11.p = 6;
+          _context11.n = 7;
           return didcommEncrypt(didcommMessage, recipients, keyResolver, keyAgreementKey);
-        case 18:
-          jweDoc = _context13.sent;
-          return _context13.abrupt("return", jweDoc);
-        case 22:
-          _context13.prev = 22;
-          _context13.t0 = _context13["catch"](15);
-          console.error(_context13.t0);
+        case 7:
+          jweDoc = _context11.v;
+          return _context11.a(2, jweDoc);
+        case 8:
+          _context11.p = 8;
+          _t = _context11.v;
+          console.error(_t);
           throw new Error('Error encrypting message');
-        case 26:
-        case "end":
-          return _context13.stop();
+        case 9:
+          return _context11.a(2);
       }
-    }, _callee13, null, [[15, 22]]);
+    }, _callee11, null, [[6, 8]]);
   }));
   return _didcommCreateEncrypted.apply(this, arguments);
 }