@walletpack/core/dist/services/utility/SocketService.js

> TODO: description

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.getCerts = exports.handlePairedResponse = exports.handleApiResponse = void 0;

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _ApiService = _interopRequireDefault(require("../apis/ApiService"));

var _AuthorizedApp = _interopRequireDefault(require("../../models/AuthorizedApp"));

var Actions = _interopRequireWildcard(require("../../store/constants"));

var _StoreService = _interopRequireDefault(require("./StoreService"));

var _EventService = _interopRequireDefault(require("./EventService"));

var service;

var emit = function emit(origin, id, path, data) {
  return service.emit(origin, id, path, data);
};

var getNewKey = function getNewKey(origin, id) {
  return service.getNewKey(origin, id);
};

var handleApiResponse =
/*#__PURE__*/
function () {
  var _ref = (0, _asyncToGenerator2["default"])(
  /*#__PURE__*/
  _regenerator["default"].mark(function _callee3(request, id) {
    var existingApp, updateNonce, removeAppPermissions;
    return _regenerator["default"].wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            // 2 way authentication
            existingApp = _StoreService["default"].get().state.scatter.keychain.findApp(request.data.payload.origin);

            updateNonce =
            /*#__PURE__*/
            function () {
              var _ref2 = (0, _asyncToGenerator2["default"])(
              /*#__PURE__*/
              _regenerator["default"].mark(function _callee() {
                var clone;
                return _regenerator["default"].wrap(function _callee$(_context) {
                  while (1) {
                    switch (_context.prev = _context.next) {
                      case 0:
                        clone = _StoreService["default"].get().state.scatter.clone();
                        existingApp.nextNonce = request.data.nextNonce;
                        clone.keychain.updateOrPushApp(existingApp);
                        return _context.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, clone));

                      case 4:
                      case "end":
                        return _context.stop();
                    }
                  }
                }, _callee);
              }));

              return function updateNonce() {
                return _ref2.apply(this, arguments);
              };
            }();

            removeAppPermissions =
            /*#__PURE__*/
            function () {
              var _ref3 = (0, _asyncToGenerator2["default"])(
              /*#__PURE__*/
              _regenerator["default"].mark(function _callee2() {
                var clone;
                return _regenerator["default"].wrap(function _callee2$(_context2) {
                  while (1) {
                    switch (_context2.prev = _context2.next) {
                      case 0:
                        clone = _StoreService["default"].get().state.scatter.clone();
                        clone.keychain.removeApp(existingApp);
                        return _context2.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, clone));

                      case 3:
                      case "end":
                        return _context2.stop();
                    }
                  }
                }, _callee2);
              }));

              return function removeAppPermissions() {
                return _ref3.apply(this, arguments);
              };
            }();

            if (existingApp) {
              _context3.next = 5;
              break;
            }

            return _context3.abrupt("return");

          case 5:
            if (existingApp.checkKey(request.data.appkey)) {
              _context3.next = 7;
              break;
            }

            return _context3.abrupt("return");

          case 7:
            if (!(existingApp.nextNonce.length && !existingApp.checkNonce(request.data.nonce))) {
              _context3.next = 12;
              break;
            }

            _context3.next = 10;
            return removeAppPermissions();

          case 10:
            _context3.next = 14;
            break;

          case 12:
            _context3.next = 14;
            return updateNonce();

          case 14:
            _ApiService["default"].handler(Object.assign(request.data, {
              plugin: request.plugin
            })).then(function (result) {
              emit(existingApp.origin, id, 'api', result);
            });

          case 15:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3);
  }));

  return function handleApiResponse(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();

exports.handleApiResponse = handleApiResponse;

var handlePairedResponse =
/*#__PURE__*/
function () {
  var _ref4 = (0, _asyncToGenerator2["default"])(
  /*#__PURE__*/
  _regenerator["default"].mark(function _callee7(request, id) {
    var scatter, existingApp, linkApp, addAuthorizedApp, repair;
    return _regenerator["default"].wrap(function _callee7$(_context7) {
      while (1) {
        switch (_context7.prev = _context7.next) {
          case 0:
            scatter = _StoreService["default"].get().state.scatter;
            existingApp = scatter.keychain.findApp(request.data.origin);
            linkApp = {
              type: 'linkApp',
              payload: request.data
            };

            if (!request.data.passthrough) {
              _context7.next = 5;
              break;
            }

            return _context7.abrupt("return", emit(request.data.origin, id, 'paired', existingApp && existingApp.checkKey(request.data.appkey)));

          case 5:
            addAuthorizedApp =
            /*#__PURE__*/
            function () {
              var _ref5 = (0, _asyncToGenerator2["default"])(
              /*#__PURE__*/
              _regenerator["default"].mark(function _callee4() {
                var newKey,
                    authedApp,
                    clone,
                    _args4 = arguments;
                return _regenerator["default"].wrap(function _callee4$(_context4) {
                  while (1) {
                    switch (_context4.prev = _context4.next) {
                      case 0:
                        newKey = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : null;
                        authedApp = new _AuthorizedApp["default"](request.data.origin, newKey ? newKey : request.data.appkey);
                        clone = scatter.clone();
                        clone.keychain.updateOrPushApp(authedApp);
                        _context4.next = 6;
                        return _StoreService["default"].get().dispatch(Actions.SET_SCATTER, clone);

                      case 6:
                        emit(request.data.origin, id, 'paired', true);

                      case 7:
                      case "end":
                        return _context4.stop();
                    }
                  }
                }, _callee4);
              }));

              return function addAuthorizedApp() {
                return _ref5.apply(this, arguments);
              };
            }();

            repair =
            /*#__PURE__*/
            function () {
              var _ref6 = (0, _asyncToGenerator2["default"])(
              /*#__PURE__*/
              _regenerator["default"].mark(function _callee5() {
                var newKey;
                return _regenerator["default"].wrap(function _callee5$(_context5) {
                  while (1) {
                    switch (_context5.prev = _context5.next) {
                      case 0:
                        _context5.next = 2;
                        return getNewKey(request.data.origin, id);

                      case 2:
                        newKey = _context5.sent;

                        if (!(newKey.data.origin !== request.data.origin || newKey.data.appkey.indexOf('appkey:') === -1)) {
                          _context5.next = 5;
                          break;
                        }

                        return _context5.abrupt("return", emit(request.data.origin, id, 'paired', false));

                      case 5:
                        return _context5.abrupt("return", addAuthorizedApp(newKey.data.appkey));

                      case 6:
                      case "end":
                        return _context5.stop();
                    }
                  }
                }, _callee5);
              }));

              return function repair() {
                return _ref6.apply(this, arguments);
              };
            }();

            if (!existingApp) {
              _context7.next = 15;
              break;
            }

            if (!existingApp.checkKey(request.data.appkey)) {
              _context7.next = 12;
              break;
            }

            return _context7.abrupt("return", emit(request.data.origin, id, 'paired', true));

          case 12:
            _EventService["default"].emit('popout', linkApp).then(
            /*#__PURE__*/
            function () {
              var _ref8 = (0, _asyncToGenerator2["default"])(
              /*#__PURE__*/
              _regenerator["default"].mark(function _callee6(_ref7) {
                var result;
                return _regenerator["default"].wrap(function _callee6$(_context6) {
                  while (1) {
                    switch (_context6.prev = _context6.next) {
                      case 0:
                        result = _ref7.result;

                        if (!result) {
                          _context6.next = 5;
                          break;
                        }

                        return _context6.abrupt("return", repair());

                      case 5:
                        emit(request.data.origin, id, 'paired', false);

                      case 6:
                      case "end":
                        return _context6.stop();
                    }
                  }
                }, _callee6);
              }));

              return function (_x5) {
                return _ref8.apply(this, arguments);
              };
            }());

          case 13:
            _context7.next = 16;
            break;

          case 15:
            return _context7.abrupt("return", repair());

          case 16:
          case "end":
            return _context7.stop();
        }
      }
    }, _callee7);
  }));

  return function handlePairedResponse(_x3, _x4) {
    return _ref4.apply(this, arguments);
  };
}();
/***
 * Gets certs that allow for `wss` local connections.
 * @returns {Promise<Response | never | void>}
 */


exports.handlePairedResponse = handlePairedResponse;

var getCerts =
/*#__PURE__*/
function () {
  var _ref9 = (0, _asyncToGenerator2["default"])(
  /*#__PURE__*/
  _regenerator["default"].mark(function _callee8() {
    return _regenerator["default"].wrap(function _callee8$(_context8) {
      while (1) {
        switch (_context8.prev = _context8.next) {
          case 0:
            return _context8.abrupt("return", fetch('https://certs.get-scatter.com?rand=' + Math.round(Math.random() * 100 + 1)).then(function (res) {
              return res.json();
            }).then(function (res) {
              if (res.hasOwnProperty('key') && res.hasOwnProperty('cert')) return res;

              _EventService["default"].emit('no_certs');

              return null;
            })["catch"](function () {
              return console.error('Could not fetch certs. Probably due to a proxy, vpn, or firewall.');
            }));

          case 1:
          case "end":
            return _context8.stop();
        }
      }
    }, _callee8);
  }));

  return function getCerts() {
    return _ref9.apply(this, arguments);
  };
}();

exports.getCerts = getCerts;

var SocketService =
/*#__PURE__*/
function () {
  function SocketService() {
    (0, _classCallCheck2["default"])(this, SocketService);
  }

  (0, _createClass2["default"])(SocketService, null, [{
    key: "init",
    value: function init(_service) {
      service = _service;
    }
  }, {
    key: "initialize",
    value: function () {
      var _initialize = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee9() {
        return _regenerator["default"].wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                return _context9.abrupt("return", service.initialize());

              case 1:
              case "end":
                return _context9.stop();
            }
          }
        }, _callee9);
      }));

      function initialize() {
        return _initialize.apply(this, arguments);
      }

      return initialize;
    }()
  }, {
    key: "close",
    value: function () {
      var _close = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee10() {
        return _regenerator["default"].wrap(function _callee10$(_context10) {
          while (1) {
            switch (_context10.prev = _context10.next) {
              case 0:
                return _context10.abrupt("return", service.close());

              case 1:
              case "end":
                return _context10.stop();
            }
          }
        }, _callee10);
      }));

      function close() {
        return _close.apply(this, arguments);
      }

      return close;
    }()
  }, {
    key: "sendEvent",
    value: function () {
      var _sendEvent = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee11(event, payload, origin) {
        return _regenerator["default"].wrap(function _callee11$(_context11) {
          while (1) {
            switch (_context11.prev = _context11.next) {
              case 0:
                return _context11.abrupt("return", service.sendEvent(event, payload, origin));

              case 1:
              case "end":
                return _context11.stop();
            }
          }
        }, _callee11);
      }));

      function sendEvent(_x6, _x7, _x8) {
        return _sendEvent.apply(this, arguments);
      }

      return sendEvent;
    }()
  }, {
    key: "broadcastEvent",
    value: function () {
      var _broadcastEvent = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee12(event, payload) {
        return _regenerator["default"].wrap(function _callee12$(_context12) {
          while (1) {
            switch (_context12.prev = _context12.next) {
              case 0:
                return _context12.abrupt("return", service.broadcastEvent(event, payload));

              case 1:
              case "end":
                return _context12.stop();
            }
          }
        }, _callee12);
      }));

      function broadcastEvent(_x9, _x10) {
        return _broadcastEvent.apply(this, arguments);
      }

      return broadcastEvent;
    }()
  }]);
  return SocketService;
}();

exports["default"] = SocketService;