@walletpack/core/dist/services/secure/KeyPairService.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 _Blockchains = require("../../models/Blockchains");

var _PluginRepository = _interopRequireDefault(require("../../plugins/PluginRepository"));

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

var _Crypto = _interopRequireDefault(require("../../util/Crypto"));

var _Keypair = _interopRequireDefault(require("../../models/Keypair"));

var _HardwareService = _interopRequireDefault(require("./HardwareService"));

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

var _IdGenerator = _interopRequireDefault(require("../../util/IdGenerator"));

var _Seeder = _interopRequireDefault(require("./Seeder"));

var _publicToPrivate2;

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

  (0, _createClass2["default"])(KeyPairService, null, [{
    key: "init",
    value: function init(_publicToPrivate) {
      _publicToPrivate2 = _publicToPrivate;
    }
  }, {
    key: "getImportedKeyBlockchains",
    value: function getImportedKeyBlockchains(privateKey) {
      var blockchains = [];

      _Blockchains.BlockchainsArray.map(function (blockchainKV) {
        try {
          var plugin = _PluginRepository["default"].plugin(blockchainKV.value);

          if (plugin.validPrivateKey(privateKey)) blockchains.push(blockchainKV.value);
        } catch (e) {}
      });

      return blockchains;
    }
  }, {
    key: "isValidPrivateKey",
    value: function isValidPrivateKey(keypair) {
      return !!this.getImportedKeyBlockchains(keypair.privateKey).length;
    }
  }, {
    key: "convertHexPrivateToBuffer",
    value: function convertHexPrivateToBuffer(keypair) {
      if (typeof keypair.privateKey !== 'string') return false;
      var buffered = false;

      _Blockchains.BlockchainsArray.map(function (blockchainKV) {
        if (buffered) return;

        try {
          var plugin = _PluginRepository["default"].plugin(blockchainKV.value);

          if (plugin.validPrivateKey(keypair.privateKey)) {
            keypair.privateKey = plugin.hexPrivateToBuffer(keypair.privateKey);
            buffered = true;
          }
        } catch (e) {}
      });
    }
    /***
     * Tries to make a keypair in place from a private key
     * @param keypair
     */

  }, {
    key: "makePublicKeys",
    value: function () {
      var _makePublicKeys = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee(keypair) {
        var _this = this;

        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                keypair.publicKeys = [];
                return _context.abrupt("return", Promise.all(_Blockchains.BlockchainsArray.map(function (blockchainKV) {
                  return _this.addPublicKey(keypair, blockchainKV.value);
                })));

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

      function makePublicKeys(_x) {
        return _makePublicKeys.apply(this, arguments);
      }

      return makePublicKeys;
    }()
  }, {
    key: "addPublicKey",
    value: function () {
      var _addPublicKey = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee2(keypair, blockchain) {
        var allowDecryption,
            seed,
            plugin,
            p,
            _args2 = arguments;
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                allowDecryption = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : false;

                if (!keypair.publicKeys.find(function (x) {
                  return x.blockchain === blockchain;
                })) {
                  _context2.next = 3;
                  break;
                }

                return _context2.abrupt("return", true);

              case 3:
                if (!(keypair.isEncrypted() && !allowDecryption)) {
                  _context2.next = 7;
                  break;
                }

                return _context2.abrupt("return", false);

              case 7:
                if (!(keypair.isEncrypted() && allowDecryption)) {
                  _context2.next = 12;
                  break;
                }

                _context2.next = 10;
                return _Seeder["default"].getSeed();

              case 10:
                seed = _context2.sent;
                keypair.decrypt(seed);

              case 12:
                _context2.prev = 12;
                plugin = _PluginRepository["default"].plugin(blockchain);
                p = keypair.privateKey;
                if (typeof p !== 'string') p = plugin.bufferToHexPrivate(p);
                keypair.publicKeys.push({
                  blockchain: blockchain,
                  key: plugin.privateToPublic(p, keypair.fork)
                });
                _context2.next = 23;
                break;

              case 19:
                _context2.prev = 19;
                _context2.t0 = _context2["catch"](12);
                console.log('err', _context2.t0);
                return _context2.abrupt("return", false);

              case 23:
                return _context2.abrupt("return", true);

              case 24:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, null, [[12, 19]]);
      }));

      function addPublicKey(_x2, _x3) {
        return _addPublicKey.apply(this, arguments);
      }

      return addPublicKey;
    }()
  }, {
    key: "generateKeyPair",
    value: function () {
      var _generateKeyPair = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee3(keypair) {
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _context3.next = 2;
                return _Crypto["default"].generatePrivateKey();

              case 2:
                keypair.privateKey = _context3.sent;
                return _context3.abrupt("return", true);

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

      function generateKeyPair(_x4) {
        return _generateKeyPair.apply(this, arguments);
      }

      return generateKeyPair;
    }()
  }, {
    key: "convertKey",
    value: function convertKey(keypair, blockchain) {
      var clone = keypair.clone();
      clone.id = _IdGenerator["default"].text(24);
      clone.name = "".concat((0, _Blockchains.blockchainName)(blockchain), " copy of ").concat(keypair.name);
      clone.blockchains = [blockchain];
      clone.createdAt = +new Date();
      return clone;
    }
  }, {
    key: "saveKeyPair",
    value: function () {
      var _saveKeyPair = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee4(keypair) {
        var scatter;
        return _regenerator["default"].wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                if (!keypair.name.length) keypair.name = "Key-".concat(_IdGenerator["default"].text(8));

                if (keypair.isUnique()) {
                  _context4.next = 3;
                  break;
                }

                return _context4.abrupt("return", {
                  error: "Keypair already exists."
                });

              case 3:
                scatter = _StoreService["default"].get().state.scatter.clone();
                scatter.keychain.keypairs.push(_Keypair["default"].fromJson(keypair));
                return _context4.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));

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

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

      return saveKeyPair;
    }()
  }, {
    key: "updateKeyPair",
    value: function () {
      var _updateKeyPair = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee5(keypair) {
        var scatter;
        return _regenerator["default"].wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                if (keypair.name.length) {
                  _context5.next = 2;
                  break;
                }

                return _context5.abrupt("return");

              case 2:
                scatter = _StoreService["default"].get().state.scatter.clone();
                scatter.keychain.keypairs.find(function (x) {
                  return x.unique() === keypair.unique();
                }).name = keypair.name;
                scatter.keychain.keypairs.find(function (x) {
                  return x.unique() === keypair.unique();
                }).blockchains = keypair.blockchains;
                return _context5.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));

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

      function updateKeyPair(_x6) {
        return _updateKeyPair.apply(this, arguments);
      }

      return updateKeyPair;
    }()
  }, {
    key: "removeKeyPair",
    value: function () {
      var _removeKeyPair = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee6(keypair) {
        var scatter;
        return _regenerator["default"].wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                scatter = _StoreService["default"].get().state.scatter.clone();
                scatter.keychain.removeKeyPair(keypair);
                return _context6.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));

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

      function removeKeyPair(_x7) {
        return _removeKeyPair.apply(this, arguments);
      }

      return removeKeyPair;
    }()
  }, {
    key: "getKeyPairFromPublicKey",
    value: function getKeyPairFromPublicKey(publicKey) {
      var keypair = _StoreService["default"].get().state.scatter.keychain.keypairs.find(function (x) {
        return x.publicKeys.find(function (k) {
          return k.key === publicKey;
        });
      });

      if (keypair) return keypair.clone();

      var identity = _StoreService["default"].get().state.scatter.keychain.identities.find(function (x) {
        return x.publicKey === publicKey;
      });

      if (identity) {
        return _Keypair["default"].fromJson({
          name: identity.name,
          publicKeys: [{
            blockchain: 'eos',
            key: publicKey
          }],
          privateKey: identity.privateKey
        });
      }

      return null;
    }
  }, {
    key: "publicToPrivate",
    value: function () {
      var _publicToPrivate3 = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee7(publicKey) {
        var p, keypair;
        return _regenerator["default"].wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                if (!_publicToPrivate2) {
                  _context7.next = 6;
                  break;
                }

                _context7.next = 3;
                return _publicToPrivate2(publicKey);

              case 3:
                p = _context7.sent;

                if (!(p !== false)) {
                  _context7.next = 6;
                  break;
                }

                return _context7.abrupt("return", p);

              case 6:
                keypair = this.getKeyPairFromPublicKey(publicKey, true);
                _context7.t0 = keypair;
                _context7.next = 10;
                return _Seeder["default"].getSeed();

              case 10:
                _context7.t1 = _context7.sent;

                _context7.t0.decrypt.call(_context7.t0, _context7.t1);

                if (!keypair) {
                  _context7.next = 14;
                  break;
                }

                return _context7.abrupt("return", keypair.privateKey);

              case 14:
                return _context7.abrupt("return", null);

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

      function publicToPrivate(_x8) {
        return _publicToPrivate3.apply(this, arguments);
      }

      return publicToPrivate;
    }()
  }, {
    key: "getHardwareKeyList",
    value: function () {
      var _getHardwareKeyList = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee9(external) {
        var _this2 = this;

        var delta,
            tries,
            _args9 = arguments;
        return _regenerator["default"].wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                delta = _args9.length > 1 && _args9[1] !== undefined ? _args9[1] : 0;
                tries = _args9.length > 2 && _args9[2] !== undefined ? _args9[2] : 0;

                if (!(typeof external["interface"].getAddress !== 'function')) {
                  _context9.next = 4;
                  break;
                }

                return _context9.abrupt("return", false);

              case 4:
                if (!(tries >= 5)) {
                  _context9.next = 6;
                  break;
                }

                return _context9.abrupt("return", false);

              case 6:
                return _context9.abrupt("return", external["interface"].getAddress(delta)["catch"](
                /*#__PURE__*/
                function () {
                  var _ref = (0, _asyncToGenerator2["default"])(
                  /*#__PURE__*/
                  _regenerator["default"].mark(function _callee8(err) {
                    return _regenerator["default"].wrap(function _callee8$(_context8) {
                      while (1) {
                        switch (_context8.prev = _context8.next) {
                          case 0:
                            if (!(err.toString().match('CLA_NOT_SUPPORTED') || err.toString().match('Cannot write to HID device'))) {
                              _context8.next = 4;
                              break;
                            }

                            _context8.next = 3;
                            return _HardwareService["default"].openConnections();

                          case 3:
                            return _context8.abrupt("return", _this2.getHardwareKeyList(external, delta, tries++));

                          case 4:
                            return _context8.abrupt("return", false);

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

                  return function (_x10) {
                    return _ref.apply(this, arguments);
                  };
                }()));

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

      function getHardwareKeyList(_x9) {
        return _getHardwareKeyList.apply(this, arguments);
      }

      return getHardwareKeyList;
    }()
  }, {
    key: "loadFromHardware",
    value: function () {
      var _loadFromHardware = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee11(keypair) {
        var _this3 = this;

        var tries,
            _args11 = arguments;
        return _regenerator["default"].wrap(function _callee11$(_context11) {
          while (1) {
            switch (_context11.prev = _context11.next) {
              case 0:
                tries = _args11.length > 1 && _args11[1] !== undefined ? _args11[1] : 0;

                if (!(typeof keypair.external["interface"].getPublicKey !== 'function')) {
                  _context11.next = 3;
                  break;
                }

                return _context11.abrupt("return", false);

              case 3:
                if (!(tries >= 5)) {
                  _context11.next = 5;
                  break;
                }

                return _context11.abrupt("return", false);

              case 5:
                return _context11.abrupt("return", keypair.external["interface"].getPublicKey().then(function (key) {
                  if (_PluginRepository["default"].plugin(keypair.external.blockchain).validPublicKey(key)) {
                    keypair.external.publicKey = key;
                    keypair.publicKeys.push({
                      blockchain: keypair.external.blockchain,
                      key: key
                    });
                    return true;
                  } else return false;
                })["catch"](
                /*#__PURE__*/
                function () {
                  var _ref2 = (0, _asyncToGenerator2["default"])(
                  /*#__PURE__*/
                  _regenerator["default"].mark(function _callee10(err) {
                    return _regenerator["default"].wrap(function _callee10$(_context10) {
                      while (1) {
                        switch (_context10.prev = _context10.next) {
                          case 0:
                            if (!err.toString().match('Cannot write to HID device')) {
                              _context10.next = 4;
                              break;
                            }

                            _context10.next = 3;
                            return _HardwareService["default"].openConnections();

                          case 3:
                            return _context10.abrupt("return", _this3.loadFromHardware(keypair, tries++));

                          case 4:
                            return _context10.abrupt("return", false);

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

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

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

      function loadFromHardware(_x11) {
        return _loadFromHardware.apply(this, arguments);
      }

      return loadFromHardware;
    }()
  }, {
    key: "isHardware",
    value: function isHardware(publicKey) {
      var keypair = this.getKeyPairFromPublicKey(publicKey);
      if (!keypair) throw new Error('Keypair doesnt exist on keychain');
      return keypair.external !== null;
    }
  }]);
  return KeyPairService;
}();

exports["default"] = KeyPairService;