@walletpack/core/dist/models/Account.js

> TODO: description

"use strict";

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

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

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

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

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

var _Blockchains = require("./Blockchains");

var _Token = _interopRequireDefault(require("./Token"));

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

var Account =
/*#__PURE__*/
function () {
  function Account() {
    (0, _classCallCheck2["default"])(this, Account);
    this.keypairUnique = '';
    this.networkUnique = '';
    this.publicKey = '';
    this.name = '';
    this.authority = '';
    this.logins = 0;
    this.createdAt = +new Date();
    this.fromOrigin = null;
  }

  (0, _createClass2["default"])(Account, [{
    key: "sendable",
    value: function sendable() {
      return _PluginRepository["default"].plugin(this.blockchain()).accountsAreImported() ? this.name : this.publicKey;
    }
  }, {
    key: "formatted",
    value: function formatted() {
      return _PluginRepository["default"].plugin(this.blockchain()).accountFormatter(this);
    }
  }, {
    key: "network",
    value: function network() {
      var _this = this;

      return _StoreService["default"].get().state.scatter.settings.networks.find(function (x) {
        return x.unique() === _this.networkUnique;
      });
    }
  }, {
    key: "keypair",
    value: function keypair() {
      var _this2 = this;

      return _StoreService["default"].get().state.scatter.keychain.keypairs.find(function (x) {
        return x.unique() === _this2.keypairUnique;
      });
    }
  }, {
    key: "blockchain",
    value: function blockchain() {
      var _this3 = this;

      if (!this.keypair()) return console.error('account.blockchain() error');
      return this.keypair().publicKeys.find(function (x) {
        return x.key === _this3.publicKey;
      }).blockchain;
    }
  }, {
    key: "authorities",
    value: function authorities() {
      var _this4 = this;

      var thisKeyOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
      if (!this.authority.length) return [];
      return _StoreService["default"].get().state.scatter.keychain.accounts.filter(function (x) {
        return x.identifiable() === _this4.identifiable() && (!thisKeyOnly || x.keypairUnique === _this4.keypairUnique);
      }).sort(function (a, b) {
        return a.authority.localeCompare(b.authority);
      });
    }
  }, {
    key: "hasDangerousAuthority",
    value: function hasDangerousAuthority() {
      return this.authorities().find(function (x) {
        return x.authority === 'owner';
      });
    }
  }, {
    key: "unique",
    value: function unique() {
      return this.keypairUnique + this.networkUnique + this.name + this.authority + this.publicKey;
    }
  }, {
    key: "identifiable",
    value: function identifiable() {
      return this.networkUnique + this.sendable();
    }
  }, {
    key: "clone",
    value: function clone() {
      return Account.fromJson(JSON.parse(JSON.stringify(this)));
    }
  }, {
    key: "asReturnable",
    value: function asReturnable() {
      var returnable = _PluginRepository["default"].plugin(this.blockchain()).returnableAccount(this);

      returnable.chainId = this.network().chainId;
      returnable.isHardware = !!this.keypair().external;
      return returnable;
    }
  }, {
    key: "tokenCount",
    value: function tokenCount() {
      var systemToken = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
      if (!_StoreService["default"].get().state.balances) return 0;
      if (!_StoreService["default"].get().state.balances.hasOwnProperty(this.identifiable())) return 0;
      if (!_StoreService["default"].get().state.balances[this.identifiable()]) return 0;
      return _StoreService["default"].get().state.balances[this.identifiable()].filter(function (x) {
        return !systemToken ? true : x.identifiable() !== systemToken.identifiable();
      }).length;
    }
  }, {
    key: "tokens",
    value: function tokens() {
      var base = [this.network().systemToken()];
      if (!_StoreService["default"].get().state.balances) return base;
      if (!_StoreService["default"].get().state.balances.hasOwnProperty(this.identifiable())) return base;
      if (!_StoreService["default"].get().state.balances[this.identifiable()]) return base;
      return _StoreService["default"].get().state.balances[this.identifiable()];
    }
  }, {
    key: "balanceFor",
    value: function balanceFor(token) {
      return this.tokens().find(function (x) {
        return x.uniqueWithChain() === token.uniqueWithChain();
      });
    }
  }, {
    key: "systemBalance",
    value: function systemBalance() {
      var _this5 = this;

      var withSymbol = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
      if (!_StoreService["default"].get().state.balances) return 0;
      if (!_StoreService["default"].get().state.balances.hasOwnProperty(this.identifiable())) return 0;
      if (!_StoreService["default"].get().state.balances[this.identifiable()]) return 0;

      var systemBalance = _StoreService["default"].get().state.balances[this.identifiable()].find(function (x) {
        return _Token["default"].fromJson(x).identifiable() === _this5.network().systemToken().identifiable();
      });

      if (!systemBalance) return 0;
      return "".concat(systemBalance.amount, " ").concat(withSymbol ? systemBalance.symbol : '');
    }
  }, {
    key: "totalFiatBalance",
    value: function totalFiatBalance() {
      return this.tokens().reduce(function (acc, x) {
        acc += x.fiatBalance(false) ? parseFloat(x.fiatBalance(false)) : 0;
        return acc;
      }, 0).toFixed(2);
    }
  }], [{
    key: "placeholder",
    value: function placeholder() {
      return new Account();
    }
  }, {
    key: "fromJson",
    value: function fromJson(json) {
      return Object.assign(this.placeholder(), json);
    }
  }]);
  return Account;
}();

exports["default"] = Account;