@walletpack/core/dist/models/hardware/ExternalWallet.js

> TODO: description

"use strict";

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

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

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

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

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

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

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

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

var EXT_WALLET_TYPES = {}; // Format [ {type,name,wallet}, {type,name,wallet} ]

exports.EXT_WALLET_TYPES = EXT_WALLET_TYPES;
var WALLETS = [];

var ExternalWallet =
/*#__PURE__*/
function () {
  (0, _createClass2["default"])(ExternalWallet, null, [{
    key: "loadWallets",
    value: function loadWallets(_wallets) {
      exports.EXT_WALLET_TYPES = EXT_WALLET_TYPES = _wallets.map(function (x) {
        return (0, _defineProperty2["default"])({}, x.type, x.name);
      });
      WALLETS = _wallets;
    }
  }]);

  function ExternalWallet() {
    var _type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

    var _blockchain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

    (0, _classCallCheck2["default"])(this, ExternalWallet);
    this.id = _IdGenerator["default"].text(64);
    this.type = _type;
    this.blockchain = _blockchain;
    this.addressIndex = 0;
  }

  (0, _createClass2["default"])(ExternalWallet, [{
    key: "setup",
    value: function setup() {
      this["interface"] = getInterface(this.type, this.blockchain);
    }
  }], [{
    key: "placeholder",
    value: function placeholder() {
      return new ExternalWallet();
    }
  }, {
    key: "fromJson",
    value: function fromJson(json) {
      return Object.assign(this.placeholder(), json);
    }
  }]);
  return ExternalWallet;
}();

exports["default"] = ExternalWallet;

var getInterface = function getInterface(type, blockchain) {
  if (EXT_WALLET_TYPES.hasOwnProperty(type)) return WALLETS[type].wallet.typeToInterface(blockchain);
  return console.error('Type not defined in hardware wallets');
};

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

  (0, _createClass2["default"])(ExternalWalletInterface, [{
    key: "open",
    value: function () {
      var _open = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee() {
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return this.handler.open();

              case 2:
                return _context.abrupt("return", _context.sent);

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

      function open() {
        return _open.apply(this, arguments);
      }

      return open;
    }()
  }, {
    key: "close",
    value: function () {
      var _close = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee2() {
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return this.handler.close();

              case 2:
                return _context2.abrupt("return", _context2.sent);

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

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

      return close;
    }()
  }, {
    key: "canConnect",
    value: function () {
      var _canConnect = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee3() {
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _context3.next = 2;
                return this.handler.canConnect();

              case 2:
                return _context3.abrupt("return", _context3.sent);

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

      function canConnect() {
        return _canConnect.apply(this, arguments);
      }

      return canConnect;
    }()
  }, {
    key: "sign",
    value: function () {
      var _sign = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee4(publicKey, transaction, abi, network) {
        return _regenerator["default"].wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                _context4.next = 2;
                return this.handler.sign(publicKey, transaction, abi, network);

              case 2:
                return _context4.abrupt("return", _context4.sent);

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

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

      return sign;
    }()
  }, {
    key: "getPublicKey",
    value: function () {
      var _getPublicKey = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee5() {
        return _regenerator["default"].wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                _context5.next = 2;
                return this.handler.getPublicKey();

              case 2:
                return _context5.abrupt("return", _context5.sent);

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

      function getPublicKey() {
        return _getPublicKey.apply(this, arguments);
      }

      return getPublicKey;
    }()
  }, {
    key: "setAddressIndex",
    value: function setAddressIndex(path) {
      return this.handler.setAddressIndex(path);
    }
  }, {
    key: "availableBlockchains",
    value: function availableBlockchains() {
      return this.handler.availableBlockchains();
    }
  }]);
  return ExternalWalletInterface;
}();

exports.ExternalWalletInterface = ExternalWalletInterface;