@docknetwork/wallet-sdk-relay-service 0.4.22 → 1.4.0

package/lib/index.mjs

@@ -0,0 +1,480 @@
+import { _ as _asyncToGenerator, a as _regeneratorRuntime, d as _createForOfIteratorHelper, c as _objectSpread2 } from './_rollupPluginBabelHelpers-78739aa5.js';
+import { isBase64 } from '@polkadot/util-crypto';
+import assert from 'assert';
+import axios from 'axios';
+import { Logger } from '@docknetwork/wallet-sdk-wasm/lib/core/logger';
+import { didcommCreateEncrypted, didcommDecrypt, getDerivedAgreementKey, didcommCreateSignedJWT, DIDCOMM_TYPE_ISSUE_DIRECT } from './didcomm.mjs';
+import { toBase64, generateSignedPayload, generateSignedPayloadFromList, fromBase64 } from './payloads.mjs';
+import jwtDecode from 'jwt-decode';
+import { dockService } from '@docknetwork/wallet-sdk-wasm/lib/services/dock/service';
+import '@digitalbazaar/x25519-key-agreement-key-2020';
+import '@digitalbazaar/ed25519-verification-key-2020';
+import '@docknetwork/minimal-cipher';
+import 'uuid';
+import 'base64url';
+import 'base58-universal';
+import './did/dids.mjs';
+import '@docknetwork/sdk/utils/did';
+import '@docknetwork/sdk/verifiable-credential';
+import '@docknetwork/sdk/utils/vc/helpers';
+import '@docknetwork/universal-wallet/methods/keypairs';
+
+var serviceURL = process.env.RELAY_SERVICE_URL || 'https://relay.dock.io';
+var didcomm = {
+  encrypt: didcommCreateEncrypted,
+  decrypt: didcommDecrypt
+};
+var sendMessage = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var keyPairDoc, recipientDid, message, type, keyAgreementKey, jweMessage, _yield$generateSigned, payload, did, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          keyPairDoc = _ref.keyPairDoc, recipientDid = _ref.recipientDid, message = _ref.message, type = _ref.type;
+          assert(!!keyPairDoc, 'keyPairDoc is required');
+          assert(!!recipientDid, 'recipientDid is required');
+          assert(!!message, 'message is required');
+          _context.next = 6;
+          return getDerivedAgreementKey(keyPairDoc);
+        case 6:
+          keyAgreementKey = _context.sent;
+          _context.next = 9;
+          return didcomm.encrypt({
+            recipientDids: [recipientDid],
+            type: type || DIDCOMM_TYPE_ISSUE_DIRECT,
+            senderDid: keyPairDoc.controller,
+            payload: message,
+            keyAgreementKey: keyAgreementKey
+          });
+        case 9:
+          jweMessage = _context.sent;
+          _context.next = 12;
+          return generateSignedPayload(keyPairDoc, {
+            to: recipientDid,
+            msg: toBase64(jweMessage)
+          });
+        case 12:
+          _yield$generateSigned = _context.sent;
+          payload = _yield$generateSigned.payload;
+          did = _yield$generateSigned.did;
+          _context.prev = 15;
+          _context.next = 18;
+          return axios.post("".concat(serviceURL, "/messages/").concat(encodeURIComponent(did)), {
+            payload: toBase64(payload)
+          });
+        case 18:
+          result = _context.sent;
+          return _context.abrupt("return", result.data);
+        case 22:
+          _context.prev = 22;
+          _context.t0 = _context["catch"](15);
+          console.error(_context.t0.response);
+          return _context.abrupt("return", _context.t0);
+        case 26:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[15, 22]]);
+  }));
+  return function sendMessage(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var getMessages = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref3) {
+    var keyPairDocs, _ref3$limit, limit, _ref3$skipMessageReso, skipMessageResolution, _yield$generateSigned2, payload, dids, result, data, messages;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          keyPairDocs = _ref3.keyPairDocs, _ref3$limit = _ref3.limit, limit = _ref3$limit === void 0 ? 20 : _ref3$limit, _ref3$skipMessageReso = _ref3.skipMessageResolution, skipMessageResolution = _ref3$skipMessageReso === void 0 ? false : _ref3$skipMessageReso;
+          assert(!!keyPairDocs, 'keyPairDoc is required');
+          assert(Array.isArray(keyPairDocs), 'keyPairDocs must be an array');
+          assert(!!keyPairDocs.length, 'keyPairDocs must not be empty');
+          _context3.next = 6;
+          return dockService.waitDockReady();
+        case 6:
+          _context3.next = 8;
+          return generateSignedPayloadFromList(keyPairDocs, {
+            limit: limit
+          });
+        case 8:
+          _yield$generateSigned2 = _context3.sent;
+          payload = _yield$generateSigned2.payload;
+          dids = _yield$generateSigned2.dids;
+          _context3.prev = 11;
+          _context3.next = 14;
+          return axios.get("".concat(serviceURL, "/messages/batch-dids?dids=").concat(encodeURIComponent(JSON.stringify(dids)), "&payload=").concat(toBase64(payload), "&keepMessages=true"));
+        case 14:
+          result = _context3.sent;
+          data = result.data;
+          if (!skipMessageResolution) {
+            _context3.next = 18;
+            break;
+          }
+          return _context3.abrupt("return", data);
+        case 18:
+          _context3.next = 20;
+          return Promise.all(data.map( /*#__PURE__*/function () {
+            var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(message) {
+              var didCommMessage;
+              return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    _context2.next = 2;
+                    return resolveDidcommMessage({
+                      message: message,
+                      keyPairDocs: keyPairDocs
+                    });
+                  case 2:
+                    didCommMessage = _context2.sent;
+                    return _context2.abrupt("return", _objectSpread2(_objectSpread2(_objectSpread2({}, message), didCommMessage), {}, {
+                      msg: didCommMessage.body
+                    }));
+                  case 4:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2);
+            }));
+            return function (_x3) {
+              return _ref5.apply(this, arguments);
+            };
+          }()));
+        case 20:
+          messages = _context3.sent;
+          return _context3.abrupt("return", messages.filter(function (item) {
+            return !!item;
+          }));
+        case 24:
+          _context3.prev = 24;
+          _context3.t0 = _context3["catch"](11);
+          console.error(_context3.t0.response);
+          return _context3.abrupt("return", _context3.t0);
+        case 28:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[11, 24]]);
+  }));
+  return function getMessages(_x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+var ackMessages = function ackMessages(_ref6) {
+  var did = _ref6.did,
+    messageIds = _ref6.messageIds;
+  assert(!!did, 'did is required');
+  assert(!!messageIds, 'messageIds is required');
+  return axios.post("".concat(serviceURL, "/messages/ack"), {
+    ack: messageIds,
+    did: did
+  });
+};
+var registerDIDPushNotification = /*#__PURE__*/function () {
+  var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref7) {
+    var keyPairDocs, token, _yield$generateSigned3, payload, dids, result;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          keyPairDocs = _ref7.keyPairDocs, token = _ref7.token;
+          assert(!!keyPairDocs, 'keyPairDoc is required');
+          assert(Array.isArray(keyPairDocs), 'keyPairDocs must be an array');
+          assert(!!keyPairDocs.length, 'keyPairDocs must not be empty');
+          assert(!!token, 'token is required');
+          _context4.next = 7;
+          return generateSignedPayloadFromList(keyPairDocs, {
+            token: token
+          });
+        case 7:
+          _yield$generateSigned3 = _context4.sent;
+          payload = _yield$generateSigned3.payload;
+          dids = _yield$generateSigned3.dids;
+          _context4.prev = 10;
+          _context4.next = 13;
+          return axios.post("".concat(serviceURL, "/register/batch-dids?dids=").concat(encodeURIComponent(JSON.stringify(dids)), "&payload=").concat(toBase64(payload)));
+        case 13:
+          result = _context4.sent;
+          return _context4.abrupt("return", result.data);
+        case 17:
+          _context4.prev = 17;
+          _context4.t0 = _context4["catch"](10);
+          console.error(_context4.t0.response);
+          return _context4.abrupt("return", _context4.t0);
+        case 21:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[10, 17]]);
+  }));
+  return function registerDIDPushNotification(_x4) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+function jwtHandler(_x5) {
+  return _jwtHandler.apply(this, arguments);
+}
+function _jwtHandler() {
+  _jwtHandler = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(message) {
+    var jwt;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          _context5.prev = 0;
+          _context5.next = 3;
+          return jwtDecode(message);
+        case 3:
+          jwt = _context5.sent;
+          return _context5.abrupt("return", jwt);
+        case 7:
+          _context5.prev = 7;
+          _context5.t0 = _context5["catch"](0);
+          return _context5.abrupt("return", false);
+        case 10:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5, null, [[0, 7]]);
+  }));
+  return _jwtHandler.apply(this, arguments);
+}
+function base64Handler(_x6) {
+  return _base64Handler.apply(this, arguments);
+}
+function _base64Handler() {
+  _base64Handler = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(message) {
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          if (isBase64(message)) {
+            _context6.next = 2;
+            break;
+          }
+          return _context6.abrupt("return", false);
+        case 2:
+          return _context6.abrupt("return", fromBase64(message));
+        case 3:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  }));
+  return _base64Handler.apply(this, arguments);
+}
+function jsonHandler(_x7) {
+  return _jsonHandler.apply(this, arguments);
+}
+function _jsonHandler() {
+  _jsonHandler = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(message) {
+    var json;
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          _context7.prev = 0;
+          json = JSON.parse(message);
+          return _context7.abrupt("return", json);
+        case 5:
+          _context7.prev = 5;
+          _context7.t0 = _context7["catch"](0);
+          return _context7.abrupt("return", false);
+        case 8:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7, null, [[0, 5]]);
+  }));
+  return _jsonHandler.apply(this, arguments);
+}
+var messageHandlers = [base64Handler, jwtHandler, jsonHandler];
+function resolveJweString(_x8) {
+  return _resolveJweString.apply(this, arguments);
+}
+function _resolveJweString() {
+  _resolveJweString = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(message) {
+    var resolvedMessage, _iterator, _step, handler, _result;
+    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          resolvedMessage = message;
+          _context8.prev = 1;
+          _iterator = _createForOfIteratorHelper(messageHandlers);
+          _context8.prev = 3;
+          _iterator.s();
+        case 5:
+          if ((_step = _iterator.n()).done) {
+            _context8.next = 13;
+            break;
+          }
+          handler = _step.value;
+          _context8.next = 9;
+          return handler(resolvedMessage);
+        case 9:
+          _result = _context8.sent;
+          if (_result) {
+            resolvedMessage = _result;
+          }
+        case 11:
+          _context8.next = 5;
+          break;
+        case 13:
+          _context8.next = 18;
+          break;
+        case 15:
+          _context8.prev = 15;
+          _context8.t0 = _context8["catch"](3);
+          _iterator.e(_context8.t0);
+        case 18:
+          _context8.prev = 18;
+          _iterator.f();
+          return _context8.finish(18);
+        case 21:
+          _context8.next = 28;
+          break;
+        case 23:
+          _context8.prev = 23;
+          _context8.t1 = _context8["catch"](1);
+          Logger.debug("Invalid JWE message received: ".concat(message));
+          console.error(_context8.t1);
+          return _context8.abrupt("return", null);
+        case 28:
+          return _context8.abrupt("return", resolvedMessage);
+        case 29:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8, null, [[1, 23], [3, 15, 18, 21]]);
+  }));
+  return _resolveJweString.apply(this, arguments);
+}
+function isURL(str) {
+  try {
+    // eslint-disable-next-line no-new
+    new URL(str);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+function resolveDidcommMessage(_x9) {
+  return _resolveDidcommMessage.apply(this, arguments);
+}
+function _resolveDidcommMessage() {
+  _resolveDidcommMessage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(_ref9) {
+    var _jwe;
+    var keyPairDocs, message, jwe, _yield$axios$get, data, result, didCommRecipients, keyPairDoc, keyAgreementKey;
+    return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          keyPairDocs = _ref9.keyPairDocs, message = _ref9.message;
+          assert(!!keyPairDocs, 'keyPairDoc is required');
+          assert(Array.isArray(keyPairDocs), 'keyPairDocs must be an array');
+          assert(!!keyPairDocs.length, 'keyPairDocs must not be empty');
+          jwe = message.msg || message;
+          if (jwe && jwe.indexOf('didcomm://') > -1) {
+            jwe = jwe.replace('didcomm://', '');
+          }
+          if (!isURL(jwe)) {
+            _context9.next = 19;
+            break;
+          }
+          _context9.prev = 7;
+          _context9.next = 10;
+          return axios.get(jwe);
+        case 10:
+          _yield$axios$get = _context9.sent;
+          data = _yield$axios$get.data;
+          jwe = data;
+          _context9.next = 19;
+          break;
+        case 15:
+          _context9.prev = 15;
+          _context9.t0 = _context9["catch"](7);
+          console.error(_context9.t0);
+          return _context9.abrupt("return", null);
+        case 19:
+          try {
+            // Parse JSON strings
+            jwe = JSON.parse(jwe);
+          } catch (_err) {}
+          if (!(typeof jwe === 'string')) {
+            _context9.next = 24;
+            break;
+          }
+          _context9.next = 23;
+          return resolveJweString(jwe);
+        case 23:
+          jwe = _context9.sent;
+        case 24:
+          result = jwe;
+          didCommRecipients = (_jwe = jwe) === null || _jwe === void 0 || (_jwe = _jwe.recipients) === null || _jwe === void 0 ? void 0 : _jwe.map(function (recipient) {
+            return recipient.header.kid;
+          }); // if no recipients, the message is not encrypted
+          if (!didCommRecipients) {
+            _context9.next = 35;
+            break;
+          }
+          keyPairDoc = keyPairDocs.find(function (doc) {
+            return didCommRecipients.find(function (did) {
+              return did.indexOf(doc.controller) > -1;
+            });
+          });
+          assert(!!keyPairDoc, "keyPairDoc not found for recipients ".concat(JSON.stringify(didCommRecipients)));
+          _context9.next = 31;
+          return getDerivedAgreementKey(keyPairDoc);
+        case 31:
+          keyAgreementKey = _context9.sent;
+          _context9.next = 34;
+          return didcommDecrypt(jwe, keyAgreementKey);
+        case 34:
+          result = _context9.sent;
+        case 35:
+          if (!result.body && result.payload) {
+            result.body = result.payload;
+          }
+          return _context9.abrupt("return", result);
+        case 37:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9, null, [[7, 15]]);
+  }));
+  return _resolveDidcommMessage.apply(this, arguments);
+}
+function signJwt(_x10) {
+  return _signJwt.apply(this, arguments);
+}
+function _signJwt() {
+  _signJwt = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(_ref10) {
+    var keyPairDocs, message;
+    return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          keyPairDocs = _ref10.keyPairDocs, message = _ref10.message;
+          _context10.next = 3;
+          return didcommCreateSignedJWT(message, keyPairDocs, true);
+        case 3:
+          return _context10.abrupt("return", _context10.sent);
+        case 4:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  }));
+  return _signJwt.apply(this, arguments);
+}
+var setServiceURL = function setServiceURL(_ref11) {
+  var url = _ref11.url;
+  assert(!!url, 'url is required');
+  serviceURL = url;
+};
+var RelayService = {
+  sendMessage: sendMessage,
+  getMessages: getMessages,
+  resolveDidcommMessage: resolveDidcommMessage,
+  registerDIDPushNotification: registerDIDPushNotification,
+  setServiceURL: setServiceURL,
+  ackMessages: ackMessages,
+  serviceURL: serviceURL,
+  signJwt: signJwt
+};
+
+export { RelayService, didcomm, resolveDidcommMessage };

package/lib/payloads.js

@@ -0,0 +1,146 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('./_rollupPluginBabelHelpers-4923c894.js');
+var VerifiableCredential = require('@docknetwork/sdk/verifiable-credential');
+var utilCrypto = require('@polkadot/util-crypto');
+var helpers = require('@docknetwork/sdk/utils/vc/helpers');
+var keypairs = require('@docknetwork/universal-wallet/methods/keypairs');
+var assert = require('assert');
+var base64url = require('base64url');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var VerifiableCredential__default = /*#__PURE__*/_interopDefaultLegacy(VerifiableCredential);
+var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+var base64url__default = /*#__PURE__*/_interopDefaultLegacy(base64url);
+
+// 1 year
+var DEFAULT_EXPIRATION = 86400 * 1000 * 365;
+var isDIDDockRegex = /did:dock/gi;
+function ensureDIDDockFragment(keyDoc) {
+  if (!isDIDDockRegex.test(keyDoc.id)) {
+    return keyDoc;
+  }
+  keyDoc.id = keyDoc.id.replace(/#.+/, '');
+  keyDoc.id = "".concat(keyDoc.id, "#keys-1");
+  return keyDoc;
+}
+function generateSignedPayload(_x, _x2) {
+  return _generateSignedPayload.apply(this, arguments);
+}
+function _generateSignedPayload() {
+  _generateSignedPayload = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee(keyPairDoc, subject) {
+    var cred, keyPair, suite;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          assert__default["default"](!!keyPairDoc, 'keyPairDoc is required');
+          assert__default["default"](!!subject, 'subject is required');
+          _context.next = 4;
+          return utilCrypto.cryptoWaitReady();
+        case 4:
+          keyPairDoc = ensureDIDDockFragment(keyPairDoc);
+          cred = new VerifiableCredential__default["default"]('dock:relay');
+          cred.setContext(['https://www.w3.org/2018/credentials/v1', {
+            dk: 'https://ld.dock.io/credentials#',
+            RelayAuthCredential: 'dk:RelayAuthCredential',
+            token: 'dk:token',
+            limit: 'dk:limit',
+            to: 'dk:to',
+            msg: 'dk:msg'
+          }]);
+          cred.setIssuanceDate(new Date().toISOString());
+          cred.setExpirationDate(new Date(Date.now() + DEFAULT_EXPIRATION).toISOString());
+          cred.setSubject(subject);
+          cred.setIssuer(keyPairDoc.controller);
+          cred.addType('RelayAuthCredential');
+          keyPair = keypairs.getKeypairFromDoc(keyPairDoc);
+          keyPair.signer = keyPair.signer();
+          _context.next = 16;
+          return helpers.getSuiteFromKeyDoc(keyPair);
+        case 16:
+          suite = _context.sent;
+          _context.next = 19;
+          return cred.sign(suite);
+        case 19:
+          return _context.abrupt("return", {
+            payload: [subject, cred.issuanceDate, cred.expirationDate, cred.toJSON().proof],
+            did: keyPairDoc.controller
+          });
+        case 20:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _generateSignedPayload.apply(this, arguments);
+}
+function generateSignedPayloadFromList(_x3, _x4) {
+  return _generateSignedPayloadFromList.apply(this, arguments);
+}
+function _generateSignedPayloadFromList() {
+  _generateSignedPayloadFromList = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee2(keyPairDocs, subject) {
+    var payload, dids, _iterator, _step, keyPairDoc, _yield$generateSigned, signedPayload, did;
+    return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          payload = [];
+          dids = [];
+          _iterator = _rollupPluginBabelHelpers._createForOfIteratorHelper(keyPairDocs);
+          _context2.prev = 3;
+          _iterator.s();
+        case 5:
+          if ((_step = _iterator.n()).done) {
+            _context2.next = 16;
+            break;
+          }
+          keyPairDoc = _step.value;
+          _context2.next = 9;
+          return generateSignedPayload(keyPairDoc, subject);
+        case 9:
+          _yield$generateSigned = _context2.sent;
+          signedPayload = _yield$generateSigned.payload;
+          did = _yield$generateSigned.did;
+          payload.push(signedPayload);
+          dids.push(did);
+        case 14:
+          _context2.next = 5;
+          break;
+        case 16:
+          _context2.next = 21;
+          break;
+        case 18:
+          _context2.prev = 18;
+          _context2.t0 = _context2["catch"](3);
+          _iterator.e(_context2.t0);
+        case 21:
+          _context2.prev = 21;
+          _iterator.f();
+          return _context2.finish(21);
+        case 24:
+          return _context2.abrupt("return", {
+            payload: payload,
+            dids: dids
+          });
+        case 25:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[3, 18, 21, 24]]);
+  }));
+  return _generateSignedPayloadFromList.apply(this, arguments);
+}
+function toBase64(payload) {
+  return base64url__default["default"].encode(JSON.stringify(payload));
+}
+function fromBase64(payload) {
+  return JSON.parse(base64url__default["default"].decode(payload));
+}
+
+exports.ensureDIDDockFragment = ensureDIDDockFragment;
+exports.fromBase64 = fromBase64;
+exports.generateSignedPayload = generateSignedPayload;
+exports.generateSignedPayloadFromList = generateSignedPayloadFromList;
+exports.toBase64 = toBase64;