@walletpack/core/dist/services/apps/PermissionService.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"] = void 0;

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

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

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

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

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

var _Permission = _interopRequireDefault(require("../../models/Permission"));

var _Identity = require("../../models/Identity");

var _SocketService = _interopRequireDefault(require("../utility/SocketService"));

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

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

  (0, _createClass2["default"])(PermissionService, null, [{
    key: "identityFromPermissions",
    value: function identityFromPermissions(origin) {
      var formatForResult = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      var permissions = _StoreService["default"].get().state.scatter.keychain.permissions;

      var possibleId = permissions.find(function (x) {
        return x.isIdentityPermissionFor(origin);
      });

      if (possibleId) {
        var identityRequirements = _Identity.IdentityRequiredFields.fromPermission(possibleId.identityRequirements);

        var identity = formatForResult ? possibleId.getIdentity().asOnlyRequiredFields(identityRequirements) : possibleId.getIdentity();
        if (!identity) return null;
        identity.accounts = possibleId.getAccounts().map(function (x) {
          return formatForResult ? x.asReturnable() : x;
        });
        return identity;
      }

      return null;
    }
  }, {
    key: "addIdentityOriginPermission",
    value: function () {
      var _addIdentityOriginPermission = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee(identity, accounts, identityRequirements, origin) {
        var scatter, permission;
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                identityRequirements = _Identity.IdentityRequiredFields.fromJson(identityRequirements);
                identityRequirements = identityRequirements.forPermission();
                _context.next = 4;
                return this.removeIdentityPermission(origin);

              case 4:
                scatter = _StoreService["default"].get().state.scatter.clone();
                permission = _Permission["default"].fromAction(origin, identity, accounts, {
                  identityRequirements: identityRequirements,
                  isIdentity: true
                });
                scatter.keychain.permissions.push(permission);
                return _context.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));

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

      function addIdentityOriginPermission(_x, _x2, _x3, _x4) {
        return _addIdentityOriginPermission.apply(this, arguments);
      }

      return addIdentityOriginPermission;
    }()
  }, {
    key: "removeIdentityPermission",
    value: function () {
      var _removeIdentityPermission = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee2(origin) {
        var scatter;
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                scatter = _StoreService["default"].get().state.scatter.clone(); // const idPermissions = scatter.keychain.permissions.find(x => x.isIdentity && x.origin === origin);
                // if(!idPermissions) return true;

                scatter.keychain.permissions = scatter.keychain.permissions.filter(function (x) {
                  return !x.isIdentity || x.isIdentity && x.origin !== origin;
                });
                return _context2.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));

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

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

      return removeIdentityPermission;
    }()
  }, {
    key: "addIdentityRequirementsPermission",
    value: function () {
      var _addIdentityRequirementsPermission = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee3(origin, identity, identityRequirements) {
        var scatter, permission;
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                identityRequirements = _Identity.IdentityRequiredFields.fromJson(identityRequirements); // No need for a permission.

                if (!identityRequirements.isEmpty()) {
                  _context3.next = 3;
                  break;
                }

                return _context3.abrupt("return");

              case 3:
                identityRequirements = identityRequirements.forPermission();
                scatter = _StoreService["default"].get().state.scatter.clone();
                permission = _Permission["default"].fromJson({
                  origin: origin,
                  identity: identity.id,
                  identityRequirements: identityRequirements,
                  isIdentityRequirements: true
                }); // Don't duplicate requirements.

                if (!scatter.keychain.permissions.find(function (x) {
                  return x.checksum() === permission.checksum();
                })) {
                  _context3.next = 8;
                  break;
                }

                return _context3.abrupt("return");

              case 8:
                scatter.keychain.permissions.push(permission);
                return _context3.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));

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

      function addIdentityRequirementsPermission(_x6, _x7, _x8) {
        return _addIdentityRequirementsPermission.apply(this, arguments);
      }

      return addIdentityRequirementsPermission;
    }()
  }, {
    key: "hasIdentityRequirementsPermission",
    value: function hasIdentityRequirementsPermission(origin, identity, identityRequirements) {
      identityRequirements = _Identity.IdentityRequiredFields.fromJson(identityRequirements);
      identityRequirements = identityRequirements.forPermission();

      var permission = _Permission["default"].fromJson({
        origin: origin,
        identity: identity.id,
        identityRequirements: identityRequirements,
        isIdentityRequirements: true
      });

      return _StoreService["default"].get().state.scatter.keychain.permissions.find(function (x) {
        return x.checksum() === permission.checksum();
      });
    }
  }, {
    key: "createActionPermission",
    value: function createActionPermission(origin, identity, accounts, whitelistData) {
      var immutableActionFields = _Permission["default"].createImmutableFieldsHash(whitelistData.fields, whitelistData.props);

      var permission = _Permission["default"].fromAction(origin, identity, accounts, {
        contract: whitelistData.code,
        contractHash: whitelistData.hash || null,
        action: whitelistData.type,
        immutableActionFields: immutableActionFields,
        mutableActionFields: whitelistData.props,
        timestamp: +new Date(),
        isContractAction: true
      });

      var scatter = _StoreService["default"].get().state.scatter.clone();

      return permission;
    }
  }, {
    key: "addActionPermissions",
    value: function () {
      var _addActionPermissions = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee4(origin, identity, accounts, whitelists) {
        var permissions, scatter;
        return _regenerator["default"].wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                if (!(!whitelists || !whitelists.length)) {
                  _context4.next = 2;
                  break;
                }

                return _context4.abrupt("return");

              case 2:
                permissions = whitelists.map(function (whitelist) {
                  return PermissionService.createActionPermission(origin, identity, accounts, whitelist);
                }).filter(function (x) {
                  return x;
                });

                if (!permissions.length) {
                  _context4.next = 8;
                  break;
                }

                scatter = _StoreService["default"].get().state.scatter.clone();
                permissions.map(function (perm) {
                  // Removing all similar permissions for this action
                  var similar = scatter.keychain.permissions.filter(function (x) {
                    return x.origin === origin && x.isContractAction && x.contract === perm.contract && x.action === perm.action;
                  }).map(function (x) {
                    return x.id;
                  });
                  scatter.keychain.permissions = scatter.keychain.permissions.filter(function (x) {
                    return !similar.includes(x.id);
                  });
                  scatter.keychain.permissions.push(perm);
                });
                _context4.next = 8;
                return _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter);

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

      function addActionPermissions(_x9, _x10, _x11, _x12) {
        return _addActionPermissions.apply(this, arguments);
      }

      return addActionPermissions;
    }()
  }, {
    key: "hasActionPermission",
    value: function hasActionPermission(origin, identity, accounts, message) {
      var contract = message.code;
      var action = message.type;
      var contractHash = null;

      var permission = _Permission["default"].fromAction(origin, identity, accounts, {
        contract: contract,
        contractHash: contractHash,
        action: action,
        isContractAction: true
      });

      var matchingPermissions = _StoreService["default"].get().state.scatter.keychain.permissions.filter(function (x) {
        return x.checksum() === permission.checksum();
      });

      if (!matchingPermissions.length) return false;
      return matchingPermissions.some(function (perm) {
        var immutableActionFields = _Permission["default"].createImmutableFieldsHash(message.data, perm.mutableActionFields);

        return perm.immutableActionFields === immutableActionFields;
      });
    }
  }, {
    key: "isWhitelistedTransaction",
    value: function isWhitelistedTransaction(origin, identity, accounts, messages, requiredFields) {
      requiredFields = _Identity.IdentityRequiredFields.fromJson(requiredFields); // Checking for permissions

      var whitelistedActions = messages.every(function (message) {
        return PermissionService.hasActionPermission(origin, identity, accounts, message);
      }); // Not all actions are whitelisted

      if (!whitelistedActions) return false; // Dont need to check for required fields

      if (requiredFields.isEmpty()) return true;
      return PermissionService.hasIdentityRequirementsPermission(origin, identity, requiredFields);
    }
  }, {
    key: "checkAppLinkPermissions",
    value: function checkAppLinkPermissions(origin) {
      var permissions = _StoreService["default"].get().state.scatter.keychain.permissions.filter(function (x) {
        return x.origin === origin;
      });

      if (!permissions.length) _SocketService["default"].sendEvent('logout', {}, origin);
    }
  }, {
    key: "removeAllPermissions",
    value: function () {
      var _removeAllPermissions = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee5() {
        var scatter;
        return _regenerator["default"].wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                scatter = _StoreService["default"].get().state.scatter.clone();
                scatter.keychain.permissions = [];
                scatter.keychain.apps.map(function (app) {
                  scatter.keychain.removeApp(app);

                  _SocketService["default"].sendEvent('logout', {}, app.origin);
                });
                return _context5.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));

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

      function removeAllPermissions() {
        return _removeAllPermissions.apply(this, arguments);
      }

      return removeAllPermissions;
    }()
  }, {
    key: "removeAllPermissionsFor",
    value: function () {
      var _removeAllPermissionsFor = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee6(origin) {
        var scatter, app;
        return _regenerator["default"].wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                scatter = _StoreService["default"].get().state.scatter.clone();
                app = scatter.keychain.apps.find(function (x) {
                  return x.origin === origin;
                });
                if (app) scatter.keychain.removeApp(app);
                scatter.keychain.permissions = scatter.keychain.permissions.filter(function (x) {
                  return x.origin !== origin;
                });
                _context6.next = 6;
                return _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter);

              case 6:
                this.checkAppLinkPermissions(origin);
                return _context6.abrupt("return", true);

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

      function removeAllPermissionsFor(_x13) {
        return _removeAllPermissionsFor.apply(this, arguments);
      }

      return removeAllPermissionsFor;
    }()
  }, {
    key: "removePermission",
    value: function () {
      var _removePermission = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee7(permission) {
        var scatter;
        return _regenerator["default"].wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                scatter = _StoreService["default"].get().state.scatter.clone();
                scatter.keychain.permissions = scatter.keychain.permissions.filter(function (x) {
                  return x.id !== permission.id;
                });
                _context7.next = 4;
                return _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter);

              case 4:
                this.checkAppLinkPermissions(permission.origin);
                return _context7.abrupt("return", true);

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

      function removePermission(_x14) {
        return _removePermission.apply(this, arguments);
      }

      return removePermission;
    }()
  }, {
    key: "removeDanglingPermissions",
    value: function () {
      var _removeDanglingPermissions = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee8() {
        var scatter, origins;
        return _regenerator["default"].wrap(function _callee8$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                scatter = _StoreService["default"].get().state.scatter.clone();
                origins = scatter.keychain.permissions.map(function (x) {
                  return x.origin;
                });
                scatter.keychain.apps = scatter.keychain.apps.filter(function (x) {
                  return origins.includes(x.origin);
                });
                return _context8.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));

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

      function removeDanglingPermissions() {
        return _removeDanglingPermissions.apply(this, arguments);
      }

      return removeDanglingPermissions;
    }()
  }]);
  return PermissionService;
}();

exports["default"] = PermissionService;