@walletpack/core
Version:
> TODO: description
610 lines (525 loc) • 23.8 kB
JavaScript
"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 _Account = _interopRequireDefault(require("../../models/Account"));
var _PluginRepository = _interopRequireDefault(require("../../plugins/PluginRepository"));
var Actions = _interopRequireWildcard(require("../../store/constants"));
var _Blockchains = require("../../models/Blockchains");
var _StoreService = _interopRequireDefault(require("../utility/StoreService"));
var _BalanceService = _interopRequireDefault(require("./BalanceService"));
var checkedOrphanedAccounts = false;
var AccountService =
/*#__PURE__*/
function () {
function AccountService() {
(0, _classCallCheck2["default"])(this, AccountService);
}
(0, _createClass2["default"])(AccountService, null, [{
key: "addAccount",
value: function () {
var _addAccount = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee(account) {
var scatter;
return _regenerator["default"].wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
scatter = _StoreService["default"].get().state.scatter.clone();
scatter.keychain.addAccount(account);
return _context.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));
case 3:
case "end":
return _context.stop();
}
}
}, _callee);
}));
function addAccount(_x) {
return _addAccount.apply(this, arguments);
}
return addAccount;
}()
}, {
key: "removeAccounts",
value: function () {
var _removeAccounts = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee2(accounts) {
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();
accounts.map(function (account) {
return scatter.keychain.removeAccount(account);
});
_context2.next = 4;
return _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter);
case 4:
return _context2.abrupt("return", _BalanceService["default"].removeStaleBalances());
case 5:
case "end":
return _context2.stop();
}
}
}, _callee2);
}));
function removeAccounts(_x2) {
return _removeAccounts.apply(this, arguments);
}
return removeAccounts;
}()
}, {
key: "getAccountsFor",
value: function () {
var _getAccountsFor = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee3(keypair, network) {
var publicKey, accounts, plugin;
return _regenerator["default"].wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
publicKey = keypair.publicKeys.find(function (x) {
return x.blockchain === network.blockchain;
}).key;
if (publicKey) {
_context3.next = 3;
break;
}
return _context3.abrupt("return", null);
case 3:
accounts = [];
plugin = _PluginRepository["default"].plugin(network.blockchain);
if (plugin.accountsAreImported()) {
_context3.next = 9;
break;
}
accounts.push(_Account["default"].fromJson({
keypairUnique: keypair.unique(),
networkUnique: network.unique(),
publicKey: publicKey
}));
_context3.next = 11;
break;
case 9:
_context3.next = 11;
return AccountService.accountsFrom(plugin, [network], accounts, keypair);
case 11:
return _context3.abrupt("return", accounts);
case 12:
case "end":
return _context3.stop();
}
}
}, _callee3);
}));
function getAccountsFor(_x3, _x4) {
return _getAccountsFor.apply(this, arguments);
}
return getAccountsFor;
}()
}, {
key: "importAllAccounts",
value: function () {
var _importAllAccounts = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee6(keypair) {
var isNewKeypair,
blockchains,
networks,
addOnly,
_args6 = arguments;
return _regenerator["default"].wrap(function _callee6$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
isNewKeypair = _args6.length > 1 && _args6[1] !== undefined ? _args6[1] : false;
blockchains = _args6.length > 2 && _args6[2] !== undefined ? _args6[2] : null;
networks = _args6.length > 3 && _args6[3] !== undefined ? _args6[3] : null;
addOnly = _args6.length > 4 && _args6[4] !== undefined ? _args6[4] : false;
return _context6.abrupt("return", new Promise(
/*#__PURE__*/
function () {
var _ref = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee5(resolve) {
var scatter, accounts, uniques, accountsToRemove;
return _regenerator["default"].wrap(function _callee5$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
scatter = _StoreService["default"].get().state.scatter.clone();
accounts = [];
if (!networks) networks = scatter.settings.networks;
if (!blockchains) blockchains = keypair.blockchains;
_context5.next = 6;
return Promise.all(blockchains.map(
/*#__PURE__*/
function () {
var _ref2 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee4(blockchain) {
var plugin, filteredNetworks;
return _regenerator["default"].wrap(function _callee4$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
plugin = _PluginRepository["default"].plugin(blockchain);
filteredNetworks = networks.filter(function (x) {
return x.blockchain === blockchain;
});
if (!(isNewKeypair && plugin.accountsAreImported())) {
_context4.next = 4;
break;
}
return _context4.abrupt("return", true);
case 4:
return _context4.abrupt("return", AccountService.accountsFrom(plugin, filteredNetworks, accounts, keypair));
case 5:
case "end":
return _context4.stop();
}
}
}, _callee4);
}));
return function (_x7) {
return _ref2.apply(this, arguments);
};
}()));
case 6:
uniques = accounts.map(function (x) {
return x.unique();
});
accountsToRemove = scatter.keychain.accounts.filter(function (x) {
return x.keypairUnique === keypair.unique() && !uniques.includes(x.unique()) && blockchains.includes(x.blockchain);
}); // This method takes a while, re-cloning to make sure we're
// always up to date before committing the data to storage.
scatter = _StoreService["default"].get().state.scatter.clone();
if (!addOnly) accountsToRemove.map(function (account) {
return scatter.keychain.removeAccount(account);
});
accounts.map(function (account) {
return scatter.keychain.addAccount(account);
});
_context5.next = 13;
return _BalanceService["default"].removeStaleBalances();
case 13:
_context5.next = 15;
return _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter);
case 15:
setTimeout(function () {
resolve(accounts);
}, 100);
case 16:
case "end":
return _context5.stop();
}
}
}, _callee5);
}));
return function (_x6) {
return _ref.apply(this, arguments);
};
}()));
case 5:
case "end":
return _context6.stop();
}
}
}, _callee6);
}));
function importAllAccounts(_x5) {
return _importAllAccounts.apply(this, arguments);
}
return importAllAccounts;
}()
}, {
key: "importAllAccountsForNetwork",
value: function () {
var _importAllAccountsForNetwork = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee9(network) {
return _regenerator["default"].wrap(function _callee9$(_context9) {
while (1) {
switch (_context9.prev = _context9.next) {
case 0:
return _context9.abrupt("return", new Promise(
/*#__PURE__*/
function () {
var _ref3 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee8(resolve) {
var scatter, blockchain, keypairs, accounts, plugin;
return _regenerator["default"].wrap(function _callee8$(_context8) {
while (1) {
switch (_context8.prev = _context8.next) {
case 0:
scatter = _StoreService["default"].get().state.scatter.clone();
blockchain = network.blockchain;
keypairs = scatter.keychain.keypairs.filter(function (x) {
return x.blockchains.includes(blockchain);
});
accounts = [];
plugin = _PluginRepository["default"].plugin(network.blockchain);
_context8.next = 7;
return Promise.all(keypairs.map(
/*#__PURE__*/
function () {
var _ref4 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee7(keypair) {
return _regenerator["default"].wrap(function _callee7$(_context7) {
while (1) {
switch (_context7.prev = _context7.next) {
case 0:
return _context7.abrupt("return", AccountService.accountsFrom(plugin, [network], accounts, keypair));
case 1:
case "end":
return _context7.stop();
}
}
}, _callee7);
}));
return function (_x10) {
return _ref4.apply(this, arguments);
};
}()));
case 7:
// This method takes a while, re-cloning to make sure we're
// always up to date before committing the data to storage.
scatter = _StoreService["default"].get().state.scatter.clone();
accounts.map(function (account) {
return scatter.keychain.addAccount(account);
});
_context8.next = 11;
return _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter);
case 11:
resolve(accounts);
case 12:
case "end":
return _context8.stop();
}
}
}, _callee8);
}));
return function (_x9) {
return _ref3.apply(this, arguments);
};
}()));
case 1:
case "end":
return _context9.stop();
}
}
}, _callee9);
}));
function importAllAccountsForNetwork(_x8) {
return _importAllAccountsForNetwork.apply(this, arguments);
}
return importAllAccountsForNetwork;
}()
/***
* Gets accounts from networks
* @param plugin - Blockchain plugin
* @param networks - Networks to fetch from
* @param accounts - (OUT) accounts array to append to
* @param keypair - Associated keypair
* @returns {Promise<*>}
*/
}, {
key: "accountsFrom",
value: function () {
var _accountsFrom = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee12(plugin, networks, accounts, keypair) {
return _regenerator["default"].wrap(function _callee12$(_context12) {
while (1) {
switch (_context12.prev = _context12.next) {
case 0:
return _context12.abrupt("return", new Promise(
/*#__PURE__*/
function () {
var _ref5 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee11(resolve) {
return _regenerator["default"].wrap(function _callee11$(_context11) {
while (1) {
switch (_context11.prev = _context11.next) {
case 0:
if (!plugin.accountsAreImported()) {
_context11.next = 9;
break;
}
_context11.next = 3;
return Promise.all(networks.map(
/*#__PURE__*/
function () {
var _ref6 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee10(network) {
return _regenerator["default"].wrap(function _callee10$(_context10) {
while (1) {
switch (_context10.prev = _context10.next) {
case 0:
_context10.next = 2;
return plugin.getImportableAccounts(keypair, network);
case 2:
return _context10.abrupt("return", _context10.sent);
case 3:
case "end":
return _context10.stop();
}
}
}, _callee10);
}));
return function (_x16) {
return _ref6.apply(this, arguments);
};
}()));
case 3:
_context11.t0 = function (acc, arr) {
arr.map(function (account) {
accounts.push(account);
});
return acc;
};
_context11.t1 = [];
_context11.sent.reduce(_context11.t0, _context11.t1);
resolve(true);
_context11.next = 11;
break;
case 9:
networks.map(function (network) {
var key = keypair.publicKeys.find(function (x) {
return x.blockchain === network.blockchain;
});
if (key) {
accounts.push(_Account["default"].fromJson({
keypairUnique: keypair.unique(),
networkUnique: network.unique(),
publicKey: key.key
}));
}
});
resolve(true);
case 11:
case "end":
return _context11.stop();
}
}
}, _callee11);
}));
return function (_x15) {
return _ref5.apply(this, arguments);
};
}()));
case 1:
case "end":
return _context12.stop();
}
}
}, _callee12);
}));
function accountsFrom(_x11, _x12, _x13, _x14) {
return _accountsFrom.apply(this, arguments);
}
return accountsFrom;
}()
}, {
key: "incrementAccountLogins",
value: function () {
var _incrementAccountLogins = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee13(accounts) {
var ids, scatter;
return _regenerator["default"].wrap(function _callee13$(_context13) {
while (1) {
switch (_context13.prev = _context13.next) {
case 0:
ids = accounts.map(function (x) {
return x.unique();
});
scatter = _StoreService["default"].get().state.scatter.clone();
scatter.keychain.accounts.filter(function (x) {
return ids.includes(x.unique());
}).map(function (x) {
return x.logins++;
});
return _context13.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));
case 4:
case "end":
return _context13.stop();
}
}
}, _callee13);
}));
function incrementAccountLogins(_x17) {
return _incrementAccountLogins.apply(this, arguments);
}
return incrementAccountLogins;
}()
}, {
key: "fixOrphanedAccounts",
value: function () {
var _fixOrphanedAccounts = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee14() {
var scatter, keypairs, orphaned;
return _regenerator["default"].wrap(function _callee14$(_context14) {
while (1) {
switch (_context14.prev = _context14.next) {
case 0:
if (!checkedOrphanedAccounts) {
_context14.next = 2;
break;
}
return _context14.abrupt("return", true);
case 2:
checkedOrphanedAccounts = true;
scatter = _StoreService["default"].get().state.scatter.clone();
keypairs = scatter.keychain.keypairs.map(function (x) {
return x.unique();
});
orphaned = scatter.keychain.accounts.filter(function (x) {
return !keypairs.includes(x.keypairUnique);
});
if (orphaned.length) {
_context14.next = 8;
break;
}
return _context14.abrupt("return", true);
case 8:
orphaned.map(function (x) {
return scatter.keychain.removeAccount(x);
});
_context14.next = 11;
return _BalanceService["default"].removeStaleBalances();
case 11:
return _context14.abrupt("return", _StoreService["default"].get().dispatch(Actions.SET_SCATTER, scatter));
case 12:
case "end":
return _context14.stop();
}
}
}, _callee14);
}));
function fixOrphanedAccounts() {
return _fixOrphanedAccounts.apply(this, arguments);
}
return fixOrphanedAccounts;
}()
}]);
return AccountService;
}();
exports["default"] = AccountService;