@walletpack/core
Version:
> TODO: description
321 lines (271 loc) • 10.9 kB
JavaScript
;
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 _PluginRepository = _interopRequireDefault(require("../../plugins/PluginRepository"));
var Actions = _interopRequireWildcard(require("../../store/constants"));
var _StoreService = _interopRequireDefault(require("../utility/StoreService"));
var lastBalanceTime;
var BalanceService =
/*#__PURE__*/
function () {
function BalanceService() {
(0, _classCallCheck2["default"])(this, BalanceService);
}
(0, _createClass2["default"])(BalanceService, null, [{
key: "loadBalancesFor",
value: function () {
var _loadBalancesFor = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee(account) {
var returnOnly,
blockchain,
plugin,
tokens,
balances,
_args = arguments;
return _regenerator["default"].wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
returnOnly = _args.length > 1 && _args[1] !== undefined ? _args[1] : false;
_context.prev = 1;
blockchain = account.blockchain();
plugin = _PluginRepository["default"].plugin(blockchain);
tokens = _StoreService["default"].get().state.scatter.allTokens().filter(function (x) {
return x.blockchain === blockchain;
}).filter(function (x) {
return x.chainId === account.network().chainId;
});
_context.next = 7;
return plugin.balancesFor(account, tokens);
case 7:
balances = _context.sent;
if (!returnOnly) {
_context.next = 10;
break;
}
return _context.abrupt("return", {
account: account.identifiable(),
balances: balances
});
case 10:
return _context.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_BALANCES, {
account: account.identifiable(),
balances: balances
}));
case 13:
_context.prev = 13;
_context.t0 = _context["catch"](1);
return _context.abrupt("return", null);
case 16:
case "end":
return _context.stop();
}
}
}, _callee, null, [[1, 13]]);
}));
function loadBalancesFor(_x) {
return _loadBalancesFor.apply(this, arguments);
}
return loadBalancesFor;
}()
}, {
key: "loadAllBalances",
value: function () {
var _loadAllBalances = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee3() {
var force,
returnOnly,
accounts,
results,
i,
_args3 = arguments;
return _regenerator["default"].wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
force = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : false;
returnOnly = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : false;
if (!(!force && lastBalanceTime < +new Date() + 1000 * 60 * 5)) {
_context3.next = 4;
break;
}
return _context3.abrupt("return");
case 4:
lastBalanceTime = +new Date();
accounts = _StoreService["default"].get().state.scatter.keychain.accounts.reduce(function (acc, account) {
// Filtering out permission based accounts
if (!acc.find(function (x) {
return x.identifiable() === account.identifiable();
})) acc.push(account);
return acc;
}, []).sort(
/*#__PURE__*/
function () {
var _ref = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee2(account) {
var isMainnet;
return _regenerator["default"].wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
// Sorting mainnets first.
isMainnet = _PluginRepository["default"].plugin(account.blockchain()).isEndorsedNetwork(account.network());
return _context2.abrupt("return", isMainnet ? -1 : 1);
case 2:
case "end":
return _context2.stop();
}
}
}, _callee2);
}));
return function (_x2) {
return _ref.apply(this, arguments);
};
}());
results = [];
i = 0;
case 8:
if (!(i < accounts.length)) {
_context3.next = 14;
break;
}
_context3.next = 11;
return Promise.race([new Promise(function (resolve) {
return setTimeout(function () {
return resolve();
}, 20000);
}), this.loadBalancesFor(accounts[i]).then(function (x) {
return results.push(x);
})]);
case 11:
i++;
_context3.next = 8;
break;
case 14:
if (!returnOnly) {
_context3.next = 16;
break;
}
return _context3.abrupt("return", results);
case 16:
return _context3.abrupt("return", true);
case 17:
case "end":
return _context3.stop();
}
}
}, _callee3, this);
}));
function loadAllBalances() {
return _loadAllBalances.apply(this, arguments);
}
return loadAllBalances;
}()
}, {
key: "removeStaleBalances",
value: function removeStaleBalances() {
var accountKeys = _StoreService["default"].get().state.scatter.keychain.accounts.map(function (x) {
return x.identifiable();
});
var keysToRemove = Object.keys(_StoreService["default"].get().state.balances).filter(function (key) {
return !accountKeys.includes(key);
});
return _StoreService["default"].get().dispatch(Actions.REMOVE_BALANCES, keysToRemove);
}
}, {
key: "loadUntouchables",
value: function () {
var _loadUntouchables = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee4(account) {
var plugin;
return _regenerator["default"].wrap(function _callee4$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
plugin = _PluginRepository["default"].plugin(account.blockchain());
return _context4.abrupt("return", plugin.hasUntouchableTokens() ? plugin.untouchableBalance(account) : []);
case 2:
case "end":
return _context4.stop();
}
}
}, _callee4);
}));
function loadUntouchables(_x3) {
return _loadUntouchables.apply(this, arguments);
}
return loadUntouchables;
}()
}, {
key: "totalBalances",
value: function totalBalances() {
var tokens = {};
tokens['totals'] = {};
var balances = _StoreService["default"].get().state.balances;
Object.keys(balances).map(
/*#__PURE__*/
function () {
var _ref2 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee5(accountUnique) {
var account;
return _regenerator["default"].wrap(function _callee5$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
account = _StoreService["default"].get().state.scatter.keychain.accounts.find(function (x) {
return x.identifiable() === accountUnique;
});
if (account) {
_context5.next = 3;
break;
}
return _context5.abrupt("return");
case 3:
if (!tokens.hasOwnProperty(account.networkUnique)) {
tokens[account.networkUnique] = {};
}
if (!(!balances.hasOwnProperty(accountUnique) || !balances[accountUnique])) {
_context5.next = 6;
break;
}
return _context5.abrupt("return");
case 6:
balances[accountUnique].map(function (token) {
if (!tokens[account.networkUnique].hasOwnProperty(token.uniqueWithChain())) {
tokens[account.networkUnique][token.uniqueWithChain()] = token.clone();
tokens['totals'][token.uniqueWithChain()] = token.clone();
} else {
tokens[account.networkUnique][token.uniqueWithChain()].add(token.amount);
tokens['totals'][token.uniqueWithChain()].add(token.amount);
}
});
case 7:
case "end":
return _context5.stop();
}
}
}, _callee5);
}));
return function (_x4) {
return _ref2.apply(this, arguments);
};
}());
return tokens;
}
}]);
return BalanceService;
}();
exports["default"] = BalanceService;