@docknetwork/wallet-sdk-relay-service 0.4.19 → 0.4.23

package/lib/didcomm.js

@@ -0,0 +1,603 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('./_rollupPluginBabelHelpers-4923c894.js');
+var x25519KeyAgreementKey2020 = require('@digitalbazaar/x25519-key-agreement-key-2020');
+var ed25519VerificationKey2020 = require('@digitalbazaar/ed25519-verification-key-2020');
+var minimalCipher = require('@docknetwork/minimal-cipher');
+var uuid = require('uuid');
+var base64url = require('base64url');
+var did_dids = require('./did/dids.js');
+require('@docknetwork/sdk/utils/did');
+require('@docknetwork/wallet-sdk-wasm/src/services/dock/service');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var base64url__default = /*#__PURE__*/_interopDefaultLegacy(base64url);
+
+var DIDCOMM_TYPE_BASIC = 'https://didcomm.org/basicmessage/1.0/message';
+var DIDCOMM_TYPE_ISSUE_DIRECT = 'https://didcomm.org/issue-credential/2.0/issue-credential';
+var DIDCOMM_TYPE_REQUEST_ISSUE_WITH_DATA = 'https://didcomm.org/issue-credential/2.0/offer-credential';
+var userFriendlyTypeMap = {
+  issue: DIDCOMM_TYPE_ISSUE_DIRECT,
+  'request-data': DIDCOMM_TYPE_REQUEST_ISSUE_WITH_DATA
+};
+var cipher = new minimalCipher.Cipher({
+  version: 'recommended'
+});
+function decodeBase64Url(string) {
+  var buffer = base64url__default["default"].toBuffer(string);
+  return new Uint8Array(buffer.buffer, buffer.offset, buffer.length);
+}
+function potentialToArray(a) {
+  return a ? Array.isArray(a) ? a : [a] : [];
+}
+function getKeydocFromDID(_x) {
+  return _getKeydocFromDID.apply(this, arguments);
+}
+function _getKeydocFromDID() {
+  _getKeydocFromDID = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee(didUrl) {
+    var didDocument, possibleKeys, keyDoc;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return did_dids.resolveDID(didUrl);
+        case 2:
+          didDocument = _context.sent;
+          possibleKeys = [].concat(_rollupPluginBabelHelpers._toConsumableArray(potentialToArray(didDocument.verificationMethod)), _rollupPluginBabelHelpers._toConsumableArray(potentialToArray(didDocument.keyAgreement)), _rollupPluginBabelHelpers._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();
+      }
+    }, _callee);
+  }));
+  return _getKeydocFromDID.apply(this, arguments);
+}
+function isValidDID(did) {
+  var didSplit = did.split(':');
+  return didSplit[0] === 'did' && didSplit.length > 2;
+}
+function defaultKaKResolver(_x2) {
+  return _defaultKaKResolver.apply(this, arguments);
+}
+function _defaultKaKResolver() {
+  _defaultKaKResolver = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee2(keyId) {
+    var keyIdStr, keyDoc;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          keyIdStr = keyId.id || keyId;
+          _context2.next = 3;
+          return getAgreementKeydocFromDID(keyIdStr);
+        case 3:
+          keyDoc = _context2.sent;
+          if (keyDoc) {
+            _context2.next = 6;
+            break;
+          }
+          throw new Error("Cannot find key document with ID: ".concat(keyIdStr));
+        case 6:
+          _context2.next = 8;
+          return getKaKInstanceFromDocument(keyDoc);
+        case 8:
+          return _context2.abrupt("return", _context2.sent);
+        case 9:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _defaultKaKResolver.apply(this, arguments);
+}
+function defaultVerificationKeyResolver(_x3) {
+  return _defaultVerificationKeyResolver.apply(this, arguments);
+}
+function _defaultVerificationKeyResolver() {
+  _defaultVerificationKeyResolver = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee3(keyId) {
+    var keyIdStr, keyDoc;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          keyIdStr = keyId.id || keyId;
+          _context3.next = 3;
+          return getKeydocFromDID(keyIdStr);
+        case 3:
+          keyDoc = _context3.sent;
+          if (keyDoc) {
+            _context3.next = 6;
+            break;
+          }
+          throw new Error("Cannot find key document with ID: ".concat(keyIdStr));
+        case 6:
+          _context3.next = 8;
+          return ed25519VerificationKey2020.Ed25519VerificationKey2020.from(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, keyDoc), {}, {
+            keyPair: keyDoc
+          }));
+        case 8:
+          return _context3.abrupt("return", _context3.sent);
+        case 9:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _defaultVerificationKeyResolver.apply(this, arguments);
+}
+function didcommCreateSignedJWT(_x4, _x5) {
+  return _didcommCreateSignedJWT.apply(this, arguments);
+}
+function _didcommCreateSignedJWT() {
+  _didcommCreateSignedJWT = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee4(payload, privateKeyDoc) {
+    var generateJWK,
+      privateKey,
+      _privateKey$signer,
+      sign,
+      header,
+      sub_jwk,
+      newPayload,
+      headerBase64URL,
+      payloadBase64URL,
+      headerAndPayloadBase64URL,
+      signPayload,
+      signature,
+      _args4 = arguments;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          generateJWK = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : false;
+          _context4.next = 3;
+          return ed25519VerificationKey2020.Ed25519VerificationKey2020.from(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, privateKeyDoc), {}, {
+            keyPair: privateKeyDoc
+          }));
+        case 3:
+          privateKey = _context4.sent;
+          _privateKey$signer = privateKey.signer(), sign = _privateKey$signer.sign;
+          header = {
+            alg: 'EdDSA',
+            kid: privateKeyDoc.id
+          };
+          sub_jwk = generateJWK ? privateKey.toJwk() : undefined;
+          newPayload = _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, payload), sub_jwk ? {
+            sub_jwk: sub_jwk
+          } : {});
+          headerBase64URL = base64url__default["default"](JSON.stringify(header));
+          payloadBase64URL = base64url__default["default"](JSON.stringify(newPayload));
+          headerAndPayloadBase64URL = "".concat(headerBase64URL, ".").concat(payloadBase64URL);
+          signPayload = Buffer.from(headerAndPayloadBase64URL);
+          _context4.next = 14;
+          return sign({
+            data: signPayload
+          });
+        case 14:
+          signature = _context4.sent;
+          return _context4.abrupt("return", "".concat(headerAndPayloadBase64URL, ".").concat(base64url__default["default"].encode(signature)));
+        case 16:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _didcommCreateSignedJWT.apply(this, arguments);
+}
+function didcommDecodeSignedJWT(_x6, _x7) {
+  return _didcommDecodeSignedJWT.apply(this, arguments);
+}
+function _didcommDecodeSignedJWT() {
+  _didcommDecodeSignedJWT = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee5(jwt, keyResolver) {
+    var resolveKey, jwtSplit, header, alg, keyId, publicKey, _publicKey$verifier, verify, signature, signPayload, isVerified, body;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          resolveKey = keyResolver || defaultVerificationKeyResolver;
+          jwtSplit = jwt.split('.').map(function (s) {
+            return s.trim();
+          });
+          if (!(jwtSplit.length !== 3)) {
+            _context5.next = 4;
+            break;
+          }
+          throw new Error("Malformed JWT, got split length: ".concat(jwtSplit.length));
+        case 4:
+          header = JSON.parse(base64url__default["default"].decode(jwtSplit[0]));
+          alg = header.alg, keyId = header.kid;
+          if (!(!alg || !keyId)) {
+            _context5.next = 8;
+            break;
+          }
+          throw new Error('Malformed JWT header, expected alg and kid');
+        case 8:
+          _context5.next = 10;
+          return resolveKey(keyId);
+        case 10:
+          publicKey = _context5.sent;
+          _publicKey$verifier = publicKey.verifier(), verify = _publicKey$verifier.verify;
+          signature = decodeBase64Url(jwtSplit[2]);
+          signPayload = Buffer.from("".concat(jwtSplit[0], ".").concat(jwtSplit[1]));
+          _context5.next = 16;
+          return verify({
+            data: signPayload,
+            signature: signature
+          });
+        case 16:
+          isVerified = _context5.sent;
+          if (isVerified) {
+            _context5.next = 19;
+            break;
+          }
+          throw new Error('JWT cannot be verified');
+        case 19:
+          body = JSON.parse(base64url__default["default"].decode(jwtSplit[1]));
+          return _context5.abrupt("return", body);
+        case 21:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return _didcommDecodeSignedJWT.apply(this, arguments);
+}
+function didcommEncrypt(_x8, _x9, _x10, _x11) {
+  return _didcommEncrypt.apply(this, arguments);
+}
+function _didcommEncrypt() {
+  _didcommEncrypt = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee6(obj, recipients, keyResolver, senderKey) {
+    var keyAgreementKey, encryptedJWE;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          // If ed25519 is supplied, derive X25519 from it
+          keyAgreementKey = senderKey;
+          if (!(senderKey.type !== 'X25519KeyAgreementKey2020')) {
+            _context6.next = 5;
+            break;
+          }
+          _context6.next = 4;
+          return getDerivedAgreementKey(senderKey);
+        case 4:
+          keyAgreementKey = _context6.sent;
+        case 5:
+          _context6.next = 7;
+          return cipher.encryptObject({
+            obj: obj,
+            recipients: recipients,
+            keyResolver: keyResolver || defaultKaKResolver,
+            keyAgreementKey: keyAgreementKey
+          });
+        case 7:
+          encryptedJWE = _context6.sent;
+          return _context6.abrupt("return", _rollupPluginBabelHelpers._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) {
+  return _didcommDecrypt.apply(this, arguments);
+}
+function _didcommDecrypt() {
+  _didcommDecrypt = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee7(jwe, keyAgreementKey, keyResolver) {
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          return _context7.abrupt("return", 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) {
+  return _didcommSendMessage.apply(this, arguments);
+}
+function _didcommSendMessage() {
+  _didcommSendMessage = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee8(to, message) {
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          if (!(!message.typ || !message.typ.startsWith('application/didcomm'))) {
+            _context8.next = 2;
+            break;
+          }
+          throw new Error('Only DIDComm messages can be sent with this service');
+        case 2:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  }));
+  return _didcommSendMessage.apply(this, arguments);
+}
+function isValidKeyAgreementDoc(keyDoc) {
+  return keyDoc.type === 'X25519KeyAgreementKey2019' || keyDoc.type === 'X25519KeyAgreementKey2020';
+}
+function isDerivableKey(keyDoc) {
+  return keyDoc.type === 'Ed25519VerificationKey2018' || keyDoc.type === 'Ed25519VerificationKey2019' || keyDoc.type === 'Ed25519VerificationKey2020';
+}
+function getAgreementKeydocFromDID(_x17) {
+  return _getAgreementKeydocFromDID.apply(this, arguments);
+}
+function _getAgreementKeydocFromDID() {
+  _getAgreementKeydocFromDID = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee9(did) {
+    var isDIDUrl, didDocument, keyAgreements, foundDoc, firstKeyAgreement, publicKeys, derivableKey;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee9$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          if (did) {
+            _context9.next = 2;
+            break;
+          }
+          return _context9.abrupt("return", undefined);
+        case 2:
+          // Resolve actual DID document and get key agreement keys
+          isDIDUrl = did.indexOf('#') !== -1;
+          _context9.next = 5;
+          return did_dids.resolveDID(did);
+        case 5:
+          didDocument = _context9.sent;
+          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 = 11;
+            break;
+          }
+          foundDoc = keyAgreements.filter(function (keyDoc) {
+            return keyDoc.id === did && isValidKeyAgreementDoc(keyDoc);
+          })[0];
+          if (!foundDoc) {
+            _context9.next = 11;
+            break;
+          }
+          return _context9.abrupt("return", foundDoc);
+        case 11:
+          // User supplied DID, find first supported keyagreement document
+          firstKeyAgreement = keyAgreements.filter(isValidKeyAgreementDoc)[0];
+          if (!firstKeyAgreement) {
+            _context9.next = 14;
+            break;
+          }
+          return _context9.abrupt("return", firstKeyAgreement);
+        case 14:
+          // No valid key agreement found on resolution, lets derive one from a ED25519 key if we can
+          publicKeys = didDocument.publicKey ? Array.isArray(didDocument.publicKey) ? didDocument.publicKey : [didDocument.publicKey] : []; // See if DID document has any derivable keys
+          derivableKey = publicKeys.filter(isDerivableKey)[0];
+          if (!derivableKey) {
+            _context9.next = 18;
+            break;
+          }
+          return _context9.abrupt("return", getDerivedAgreementKey(derivableKey));
+        case 18:
+          throw new Error("Unable to find or derive X25519 key agreement for DID: ".concat(did));
+        case 19:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  }));
+  return _getAgreementKeydocFromDID.apply(this, arguments);
+}
+function getDerivedAgreementKey(_x18) {
+  return _getDerivedAgreementKey.apply(this, arguments);
+}
+function _getDerivedAgreementKey() {
+  _getDerivedAgreementKey = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee10(derivableKey) {
+    var ed2020VerificationKey, derivedKeyAgreement;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee10$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          if (isDerivableKey(derivableKey)) {
+            _context10.next = 2;
+            break;
+          }
+          throw new Error("Cannot derive X25519 KAK from type: ".concat(derivableKey.type));
+        case 2:
+          if (!derivableKey.publicKeyMultibase) {
+            derivableKey.publicKeyMultibase = derivableKey.publicKeyBase58;
+          }
+
+          // Convert derivable key into latest 2020 format
+          _context10.next = 5;
+          return ed25519VerificationKey2020.Ed25519VerificationKey2020.from(_rollupPluginBabelHelpers._objectSpread2({
+            keyPair: derivableKey
+          }, derivableKey));
+        case 5:
+          ed2020VerificationKey = _context10.sent;
+          // Convert ed25519 2020 verification key into a key agreement key
+          derivedKeyAgreement = x25519KeyAgreementKey2020.X25519KeyAgreementKey2020.fromEd25519VerificationKey2020(_rollupPluginBabelHelpers._objectSpread2({
+            keyPair: ed2020VerificationKey
+          }, ed2020VerificationKey));
+          return _context10.abrupt("return", derivedKeyAgreement);
+        case 8:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  }));
+  return _getDerivedAgreementKey.apply(this, arguments);
+}
+function getKaKInstanceFromDocument(_x19) {
+  return _getKaKInstanceFromDocument.apply(this, arguments);
+}
+function _getKaKInstanceFromDocument() {
+  _getKaKInstanceFromDocument = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee11(keyDoc) {
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee11$(_context11) {
+      while (1) switch (_context11.prev = _context11.next) {
+        case 0:
+          if (isValidKeyAgreementDoc(keyDoc)) {
+            _context11.next = 2;
+            break;
+          }
+          throw new Error("Invalid key document type for key agreement key: ".concat(keyDoc.type));
+        case 2:
+          _context11.next = 4;
+          return x25519KeyAgreementKey2020.X25519KeyAgreementKey2020.from(keyDoc);
+        case 4:
+          return _context11.abrupt("return", _context11.sent);
+        case 5:
+        case "end":
+          return _context11.stop();
+      }
+    }, _callee11);
+  }));
+  return _getKaKInstanceFromDocument.apply(this, arguments);
+}
+function getJWERecipientFromDocument(keyDoc, algorithm) {
+  return {
+    header: {
+      kid: keyDoc.id,
+      alg: algorithm || 'ECDH-1PU+A256KW'
+    }
+  };
+}
+
+// Defined here: https://identity.foundation/didcomm-messaging/spec/#plaintext-message-structure
+function formatPayloadToDIDComm(to, msgType, from, body, replyUrl, replyTo) {
+  var msg = {
+    id: uuid.v1(),
+    type: userFriendlyTypeMap[msgType] || msgType || DIDCOMM_TYPE_BASIC,
+    created_time: Math.floor(Date.now() / 1000),
+    // Unix timestamp, seconds
+    from: from,
+    body: body
+  };
+  if (to) {
+    msg.to = to;
+  }
+  if (replyUrl) {
+    msg.reply_url = replyUrl;
+  }
+  if (replyTo) {
+    msg.reply_to = [replyTo];
+  }
+  return msg;
+}
+function didcommCreateEncrypted(_x20) {
+  return _didcommCreateEncrypted.apply(this, arguments);
+}
+function _didcommCreateEncrypted() {
+  _didcommCreateEncrypted = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee13(_ref) {
+    var senderDid, _ref$recipientDids, recipientDids, payload, type, keyAgreementKey, algorithm, recipientKeyDocuments, recipients, keyResolver, didcommMessage, jweDoc;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee13$(_context13) {
+      while (1) switch (_context13.prev = _context13.next) {
+        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;
+            break;
+          }
+          throw new Error('Requires payload to create encrypted didcomm message');
+        case 3:
+          if (!(recipientDids.length === 0)) {
+            _context13.next = 5;
+            break;
+          }
+          throw new Error('Must supply atleast 1 recipient DID');
+        case 5:
+          if (isValidDID(senderDid)) {
+            _context13.next = 7;
+            break;
+          }
+          throw new Error('Sender DID must be a valid DID');
+        case 7:
+          if (recipientDids.every(isValidDID)) {
+            _context13.next = 9;
+            break;
+          }
+          throw new Error('Recipient DID is invalid');
+        case 9:
+          _context13.next = 11;
+          return Promise.all(recipientDids.map(getAgreementKeydocFromDID));
+        case 11:
+          recipientKeyDocuments = _context13.sent;
+          recipients = recipientKeyDocuments.map(function (keyDoc) {
+            return getJWERecipientFromDocument(keyDoc, algorithm);
+          });
+          keyResolver = /*#__PURE__*/function () {
+            var _ref2 = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee12(keyId) {
+              var keyIdStr, keyDoc, result;
+              return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee12$(_context12) {
+                while (1) switch (_context12.prev = _context12.next) {
+                  case 0:
+                    keyIdStr = keyId.id || keyId;
+                    keyDoc = recipientKeyDocuments.filter(function (k) {
+                      return k.id === keyIdStr;
+                    })[0];
+                    if (keyDoc) {
+                      _context12.next = 4;
+                      break;
+                    }
+                    throw new Error("Cannot find key document with ID: ".concat(keyIdStr));
+                  case 4:
+                    _context12.next = 6;
+                    return getKaKInstanceFromDocument(keyDoc);
+                  case 6:
+                    result = _context12.sent;
+                    return _context12.abrupt("return", result);
+                  case 8:
+                  case "end":
+                    return _context12.stop();
+                }
+              }, _callee12);
+            }));
+            return function keyResolver(_x21) {
+              return _ref2.apply(this, arguments);
+            };
+          }();
+          didcommMessage = formatPayloadToDIDComm(recipientDids, type, senderDid, payload);
+          _context13.prev = 15;
+          _context13.next = 18;
+          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);
+          throw new Error('Error encrypting message');
+        case 26:
+        case "end":
+          return _context13.stop();
+      }
+    }, _callee13, null, [[15, 22]]);
+  }));
+  return _didcommCreateEncrypted.apply(this, arguments);
+}
+
+exports.DIDCOMM_TYPE_BASIC = DIDCOMM_TYPE_BASIC;
+exports.DIDCOMM_TYPE_ISSUE_DIRECT = DIDCOMM_TYPE_ISSUE_DIRECT;
+exports.DIDCOMM_TYPE_REQUEST_ISSUE_WITH_DATA = DIDCOMM_TYPE_REQUEST_ISSUE_WITH_DATA;
+exports.defaultKaKResolver = defaultKaKResolver;
+exports.defaultVerificationKeyResolver = defaultVerificationKeyResolver;
+exports.didcommCreateEncrypted = didcommCreateEncrypted;
+exports.didcommCreateSignedJWT = didcommCreateSignedJWT;
+exports.didcommDecodeSignedJWT = didcommDecodeSignedJWT;
+exports.didcommDecrypt = didcommDecrypt;
+exports.didcommEncrypt = didcommEncrypt;
+exports.didcommSendMessage = didcommSendMessage;
+exports.formatPayloadToDIDComm = formatPayloadToDIDComm;
+exports.getAgreementKeydocFromDID = getAgreementKeydocFromDID;
+exports.getDerivedAgreementKey = getDerivedAgreementKey;
+exports.getJWERecipientFromDocument = getJWERecipientFromDocument;
+exports.getKaKInstanceFromDocument = getKaKInstanceFromDocument;
+exports.getKeydocFromDID = getKeydocFromDID;
+exports.isDerivableKey = isDerivableKey;
+exports.isValidDID = isValidDID;
+exports.isValidKeyAgreementDoc = isValidKeyAgreementDoc;
+exports.userFriendlyTypeMap = userFriendlyTypeMap;