@walletpack/core
Version:
> TODO: description
1,108 lines (923 loc) • 94.5 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 _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
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 Actions = _interopRequireWildcard(require("../../models/api/ApiActions"));
var StoreActions = _interopRequireWildcard(require("../../store/constants"));
var _ObjectHelpers = _interopRequireDefault(require("../../util/ObjectHelpers"));
var _Hasher = _interopRequireDefault(require("../../util/Hasher"));
var _IdGenerator = _interopRequireDefault(require("../../util/IdGenerator"));
var _AccountService = _interopRequireDefault(require("../blockchain/AccountService"));
var _PermissionService = _interopRequireDefault(require("../apps/PermissionService"));
var _KeyPairService = _interopRequireDefault(require("../secure/KeyPairService"));
var _ResourceService = _interopRequireDefault(require("../blockchain/ResourceService"));
var _PluginRepository = _interopRequireDefault(require("../../plugins/PluginRepository"));
var _Blockchains = require("../../models/Blockchains");
var _Keypair = _interopRequireDefault(require("../../models/Keypair"));
var _Identity = _interopRequireWildcard(require("../../models/Identity"));
var _Account = _interopRequireDefault(require("../../models/Account"));
var _Error = _interopRequireDefault(require("../../models/errors/Error"));
var _Network = _interopRequireDefault(require("../../models/Network"));
var _HardwareService = _interopRequireDefault(require("../secure/HardwareService"));
var _Token = _interopRequireDefault(require("../../models/Token"));
var _TokenService = _interopRequireDefault(require("../utility/TokenService"));
var _BalanceService = _interopRequireDefault(require("../blockchain/BalanceService"));
var _StoreService = _interopRequireDefault(require("../utility/StoreService"));
var _Framework = _interopRequireDefault(require("../utility/Framework"));
var _EventService = _interopRequireDefault(require("../utility/EventService"));
var _SigningService = _interopRequireDefault(require("../../services/secure/SigningService"));
var _eosjsEcc = _interopRequireDefault(require("eosjs-ecc"));
var blocked = [];
var ApiService =
/*#__PURE__*/
function () {
function ApiService() {
(0, _classCallCheck2["default"])(this, ApiService);
}
(0, _createClass2["default"])(ApiService, null, [{
key: "blockRoutes",
value: function blockRoutes(routes) {
blocked = routes;
}
}, {
key: "handler",
value: function () {
var _handler = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee(request) {
var result;
return _regenerator["default"].wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
if (Object.keys(Actions).map(function (key) {
return Actions[key];
}).includes(request.type)) {
_context.next = 2;
break;
}
return _context.abrupt("return");
case 2:
if (!blocked.includes(request.type)) {
_context.next = 4;
break;
}
return _context.abrupt("return", {
id: request.id,
result: _Error["default"].malicious('This wallet has turned this API route off.')
});
case 4:
_context.next = 6;
return this[request.type](request);
case 6:
result = _context.sent;
// Adding something to be able to catch API routes in integration
_EventService["default"].emit('api_response', {
request: request,
result: result
});
return _context.abrupt("return", result);
case 9:
case "end":
return _context.stop();
}
}
}, _callee, this);
}));
function handler(_x) {
return _handler.apply(this, arguments);
}
return handler;
}()
/******************************************************************************/
/** **/
/** **/
/** POPOUT METHODS **/
/** These routes cause popups for the user **/
/** **/
/** **/
/******************************************************************************/
}, {
key: Actions.LOGIN,
value: function () {
var _value = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee2(request) {
return _regenerator["default"].wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
return _context2.abrupt("return", this.loginHandler(request, false));
case 1:
case "end":
return _context2.stop();
}
}
}, _callee2, this);
}));
function value(_x2) {
return _value.apply(this, arguments);
}
return value;
}()
}, {
key: Actions.LOGIN_ALL,
value: function () {
var _value2 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee3(request) {
return _regenerator["default"].wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
return _context3.abrupt("return", this.loginHandler(request, true));
case 1:
case "end":
return _context3.stop();
}
}
}, _callee3, this);
}));
function value(_x3) {
return _value2.apply(this, arguments);
}
return value;
}()
}, {
key: "loginHandler",
value: function () {
var _loginHandler = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee5(request, loginAll) {
return _regenerator["default"].wrap(function _callee5$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
return _context5.abrupt("return", new Promise(function (resolve) {
var badResult = function badResult() {
var msg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Invalid format';
return resolve({
id: request.id,
result: _Error["default"].malicious(msg)
});
};
if (Object.keys(request.payload).length !== 2) return badResult();
if (!request.payload.hasOwnProperty('fields')) return badResult();
if ((0, _typeof2["default"])(request.payload.fields) !== 'object') return badResult();
var _request$payload = request.payload,
origin = _request$payload.origin,
fields = _request$payload.fields;
if (!fields.hasOwnProperty('personal')) fields.personal = [];
if (!fields.hasOwnProperty('location')) fields.location = [];
if (!fields.hasOwnProperty('accounts')) fields.accounts = [];
fields.personal = fields.personal.filter(function (x) {
return !!x;
});
fields.location = fields.location.filter(function (x) {
return !!x;
});
fields.accounts = fields.accounts.filter(function (x) {
return !!x;
});
var requiredNetworks = fields.accounts.map(function (x) {
return _Network["default"].fromJson(x);
}).map(function (x) {
return x.unique();
}).reduce(function (acc, x) {
if (!acc.includes(x)) acc.push(x);
return acc;
}, []); // Deprecating the ability to log in with multiple networks, citing bad UX
if (!loginAll && requiredNetworks.length > 1) {
return resolve({
id: request.id,
result: _Error["default"].signatureError("too_many_accounts", "To login more than one account you must use the `getAllAccounts()` API method.")
});
}
var existingNetworks = _StoreService["default"].get().state.scatter.settings.networks.filter(function (x) {
return requiredNetworks.includes(x.unique());
});
if (existingNetworks.length !== requiredNetworks.length) {
return resolve({
id: request.id,
result: _Error["default"].noNetwork()
});
}
var availableAccounts = existingNetworks.map(function (x) {
return x.accounts();
}).reduce(function (acc, accounts) {
acc = acc.concat(accounts);
return acc;
}, []);
var possibleId = _PermissionService["default"].identityFromPermissions(origin);
if (possibleId) {
var samePersonal = fields.personal.every(function (key) {
return possibleId.hasOwnProperty('personal') && possibleId.personal.hasOwnProperty(key);
});
var sameLocation = fields.location.every(function (key) {
return possibleId.hasOwnProperty('location') && possibleId.location.hasOwnProperty(key);
});
var sameAccounts = true;
if (loginAll && availableAccounts.length !== possibleId.accounts.length) sameAccounts = false;else if (!loginAll && possibleId.accounts.length > 1) sameAccounts = false;
if (samePersonal && sameLocation && sameAccounts) return resolve({
id: request.id,
result: possibleId
});
}
_EventService["default"].emit('popout', request).then(
/*#__PURE__*/
function () {
var _ref2 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee4(_ref) {
var result, identity, location, accounts, returnableIdentity;
return _regenerator["default"].wrap(function _callee4$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
result = _ref.result;
if (result) {
_context4.next = 3;
break;
}
return _context4.abrupt("return", resolve({
id: request.id,
result: _Error["default"].signatureError("identity_rejected", "User rejected the provision of an Identity")
}));
case 3:
// await updateIdentity(result);
// const identity = Identity.fromJson(result.identity);
identity = _StoreService["default"].get().state.scatter.keychain.identities.find(function (x) {
return x.id === result.identity.id;
});
_context4.next = 6;
return identity.setAsLastUsed();
case 6:
location = _Identity.LocationInformation.fromJson(result.location);
accounts = loginAll ? availableAccounts : (result.accounts || []).map(function (x) {
return _Account["default"].fromJson(x);
});
_context4.next = 10;
return _PermissionService["default"].addIdentityOriginPermission(identity, accounts, fields, origin);
case 10:
returnableIdentity = identity.asOnlyRequiredFields(fields, location);
returnableIdentity.accounts = accounts.map(function (x) {
return x.asReturnable();
});
if (!loginAll && accounts.length) _AccountService["default"].incrementAccountLogins(accounts);
resolve({
id: request.id,
result: returnableIdentity
});
case 14:
case "end":
return _context4.stop();
}
}
}, _callee4);
}));
return function (_x6) {
return _ref2.apply(this, arguments);
};
}());
}));
case 1:
case "end":
return _context5.stop();
}
}
}, _callee5);
}));
function loginHandler(_x4, _x5) {
return _loginHandler.apply(this, arguments);
}
return loginHandler;
}()
}, {
key: Actions.SIGN,
value: function () {
var _value3 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee11(request) {
return _regenerator["default"].wrap(function _callee11$(_context11) {
while (1) {
switch (_context11.prev = _context11.next) {
case 0:
return _context11.abrupt("return", new Promise(
/*#__PURE__*/
function () {
var _ref3 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee10(resolve) {
var payload, origin, requiredFields, blockchain, possibleId, plugin, network, blacklisted, availableAccounts, participants, identity, fillIdentity, signAndReturn, existingApp, hasHardwareKeys, sendableRequest;
return _regenerator["default"].wrap(function _callee10$(_context10) {
while (1) {
switch (_context10.prev = _context10.next) {
case 0:
payload = request.payload;
origin = payload.origin, requiredFields = payload.requiredFields, blockchain = payload.blockchain;
possibleId = _PermissionService["default"].identityFromPermissions(origin, false);
if (possibleId) {
_context10.next = 5;
break;
}
return _context10.abrupt("return", resolve({
id: request.id,
result: _Error["default"].identityMissing()
}));
case 5:
payload.identityKey = possibleId.publicKey; // Blockchain specific plugin
plugin = _PluginRepository["default"].plugin(blockchain);
network = _StoreService["default"].get().state.scatter.settings.networks.find(function (x) {
return x.unique() === _Network["default"].fromJson(payload.network).unique();
});
if (network) {
_context10.next = 10;
break;
}
return _context10.abrupt("return", resolve({
id: request.id,
result: _Error["default"].noNetwork()
}));
case 10:
payload.network = network; // Convert buf and abi to messages
_context10.next = 13;
return plugin.requestParser(payload, network, payload.abi || null);
case 13:
payload.messages = _context10.sent;
if (payload.messages) {
_context10.next = 16;
break;
}
return _context10.abrupt("return", resolve({
id: request.id,
result: _Error["default"].cantParseTransaction()
}));
case 16:
// CHECKING FOR BLACKLISTED ACTIONS
blacklisted = payload.messages.map(function (x) {
return "".concat(blockchain, "::").concat(x.code, "::").concat(x.type);
}).filter(function (actionTag) {
return _StoreService["default"].get().state.scatter.settings.isActionBlacklisted(actionTag);
});
if (!blacklisted.length) {
_context10.next = 20;
break;
}
_EventService["default"].emit('firewalled', {
actions: blacklisted,
payload: payload
});
return _context10.abrupt("return", resolve({
id: request.id,
result: _Error["default"].malicious('firewalled')
}));
case 20:
availableAccounts = possibleId.accounts.map(function (x) {
return x.formatted();
});
participants = _ObjectHelpers["default"].distinct(plugin.actionParticipants(payload)).filter(function (x) {
return availableAccounts.includes(x);
}).map(function (x) {
return possibleId.accounts.find(function (acc) {
return acc.formatted() === x;
});
}); // Must have the proper account participants.
if (participants.length) {
_context10.next = 24;
break;
}
return _context10.abrupt("return", resolve({
id: request.id,
result: _Error["default"].signatureAccountMissing()
}));
case 24:
payload.participants = participants; // Getting the identity for this transaction
fillIdentity = function fillIdentity() {
return identity = _StoreService["default"].get().state.scatter.keychain.identities.find(function (x) {
return x.publicKey === possibleId.publicKey;
});
};
fillIdentity();
signAndReturn =
/*#__PURE__*/
function () {
var _ref4 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee7(selectedLocation) {
var signatures, returnedFields;
return _regenerator["default"].wrap(function _callee7$(_context7) {
while (1) {
switch (_context7.prev = _context7.next) {
case 0:
_context7.next = 2;
return Promise.all(participants.map(
/*#__PURE__*/
function () {
var _ref5 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee6(account) {
return _regenerator["default"].wrap(function _callee6$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
return _context6.abrupt("return", _SigningService["default"].sign(network, payload, account.publicKey));
case 1:
case "end":
return _context6.stop();
}
}
}, _callee6);
}));
return function (_x10) {
return _ref5.apply(this, arguments);
};
}()));
case 2:
signatures = _context7.sent;
if (!(signatures.length !== participants.length)) {
_context7.next = 5;
break;
}
return _context7.abrupt("return", resolve({
id: request.id,
result: _Error["default"].signatureAccountMissing()
}));
case 5:
if (!(signatures.length === 1 && signatures[0] === null)) {
_context7.next = 7;
break;
}
return _context7.abrupt("return", resolve({
id: request.id,
result: _Error["default"].signatureError("signature_rejected", "User rejected the signature request")
}));
case 7:
if (!signatures.some(function (x) {
return !x;
})) {
_context7.next = 9;
break;
}
return _context7.abrupt("return", resolve({
id: request.id,
result: _Error["default"].signatureError('missing_sig', 'A signature for this request was missing')
}));
case 9:
returnedFields = _Identity["default"].asReturnedFields(requiredFields, identity, selectedLocation);
resolve({
id: request.id,
result: {
signatures: signatures,
returnedFields: returnedFields
}
});
case 11:
case "end":
return _context7.stop();
}
}
}, _callee7);
}));
return function signAndReturn(_x9) {
return _ref4.apply(this, arguments);
};
}(); // Only allowing whitelist permissions for origin authed apps
existingApp = _StoreService["default"].get().state.scatter.keychain.findApp(origin);
hasHardwareKeys = participants.some(function (x) {
return _KeyPairService["default"].isHardware(x.publicKey);
});
if (!(existingApp && !hasHardwareKeys && _PermissionService["default"].isWhitelistedTransaction(origin, identity, participants, payload.messages, requiredFields))) {
_context10.next = 35;
break;
}
if (_StoreService["default"].get().state.scatter.settings.showNotifications) _Framework["default"].pushNotification('Signed Transaction', "".concat(origin, " - ").concat(participants.map(function (x) {
return x.sendable();
}).join(',')));
_context10.next = 34;
return signAndReturn(identity.getLocation());
case 34:
return _context10.abrupt("return", _context10.sent);
case 35:
sendableRequest = {};
sendableRequest.type = request.type;
sendableRequest.appkey = request.appkey;
sendableRequest.payload = {
messages: request.payload.messages,
network: request.payload.network,
origin: request.payload.origin,
participants: request.payload.participants,
requiredFields: request.payload.requiredFields
};
_EventService["default"].emit('popout', sendableRequest).then(
/*#__PURE__*/
function () {
var _ref7 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee9(_ref6) {
var result;
return _regenerator["default"].wrap(function _callee9$(_context9) {
while (1) {
switch (_context9.prev = _context9.next) {
case 0:
result = _ref6.result;
if (result) {
_context9.next = 3;
break;
}
return _context9.abrupt("return", resolve({
id: request.id,
result: _Error["default"].signatureError("signature_rejected", "User rejected the signature request")
}));
case 3:
// await updateIdentity(result);
fillIdentity();
if (!result.needResources) {
_context9.next = 7;
break;
}
_context9.next = 7;
return Promise.all(result.needResources.map(
/*#__PURE__*/
function () {
var _ref8 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee8(account) {
return _regenerator["default"].wrap(function _callee8$(_context8) {
while (1) {
switch (_context8.prev = _context8.next) {
case 0:
_context8.next = 2;
return _ResourceService["default"].addResources(account);
case 2:
return _context8.abrupt("return", _context8.sent);
case 3:
case "end":
return _context8.stop();
}
}
}, _callee8);
}));
return function (_x12) {
return _ref8.apply(this, arguments);
};
}()));
case 7:
_context9.next = 9;
return _PermissionService["default"].addIdentityRequirementsPermission(origin, identity, requiredFields);
case 9:
_context9.next = 11;
return _PermissionService["default"].addActionPermissions(origin, identity, participants, result.whitelists);
case 11:
_context9.next = 13;
return signAndReturn(result.selectedLocation);
case 13:
case "end":
return _context9.stop();
}
}
}, _callee9);
}));
return function (_x11) {
return _ref7.apply(this, arguments);
};
}());
case 40:
case "end":
return _context10.stop();
}
}
}, _callee10);
}));
return function (_x8) {
return _ref3.apply(this, arguments);
};
}()));
case 1:
case "end":
return _context11.stop();
}
}
}, _callee11);
}));
function value(_x7) {
return _value3.apply(this, arguments);
}
return value;
}()
}, {
key: Actions.SIGN_ARBITRARY,
value: function () {
var _value4 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee14(request) {
var identityKey,
_args14 = arguments;
return _regenerator["default"].wrap(function _callee14$(_context14) {
while (1) {
switch (_context14.prev = _context14.next) {
case 0:
identityKey = _args14.length > 1 && _args14[1] !== undefined ? _args14[1] : null;
return _context14.abrupt("return", new Promise(
/*#__PURE__*/
function () {
var _ref9 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee13(resolve) {
var payload, _request$payload2, origin, publicKey, data, _possibleId, keypair, blockchain, network;
return _regenerator["default"].wrap(function _callee13$(_context13) {
while (1) {
switch (_context13.prev = _context13.next) {
case 0:
payload = request.payload;
_request$payload2 = request.payload, origin = _request$payload2.origin, publicKey = _request$payload2.publicKey, data = _request$payload2.data;
if (!(data.indexOf(':') === -1)) {
_context13.next = 5;
break;
}
if (!data.split(' ').some(function (x) {
return x.length > 12;
})) {
_context13.next = 5;
break;
}
return _context13.abrupt("return", resolve({
id: request.id,
result: _Error["default"].malicious('You can not sign strings where any of the words are over 12 characters.')
}));
case 5:
if (!identityKey) {
_context13.next = 9;
break;
}
payload.identityKey = identityKey;
_context13.next = 13;
break;
case 9:
_possibleId = _PermissionService["default"].identityFromPermissions(origin, false);
if (_possibleId) {
_context13.next = 12;
break;
}
return _context13.abrupt("return", resolve({
id: request.id,
result: _Error["default"].identityMissing()
}));
case 12:
payload.identityKey = _possibleId.publicKey;
case 13:
keypair = _KeyPairService["default"].getKeyPairFromPublicKey(publicKey);
if (keypair) {
_context13.next = 16;
break;
}
return _context13.abrupt("return", resolve({
id: request.id,
result: _Error["default"].signatureError("signature_rejected", "User rejected the signature request")
}));
case 16:
blockchain = keypair.publicKeys.find(function (x) {
return x.key === publicKey;
}).blockchain;
network = _Network["default"].fromJson({
blockchain: blockchain
}); // Convert buf and abi to messages
payload.messages = [{
code: "".concat((0, _Blockchains.blockchainName)(blockchain), " Key"),
type: 'Arbitrary Signature',
data: {
signing: data
}
}];
_EventService["default"].emit('popout', Object.assign(request, {})).then(
/*#__PURE__*/
function () {
var _ref11 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee12(_ref10) {
var result;
return _regenerator["default"].wrap(function _callee12$(_context12) {
while (1) {
switch (_context12.prev = _context12.next) {
case 0:
result = _ref10.result;
if (!(!result || !result.accepted || false)) {
_context12.next = 3;
break;
}
return _context12.abrupt("return", resolve({
id: request.id,
result: _Error["default"].signatureError("signature_rejected", "User rejected the signature request")
}));
case 3:
_context12.t0 = resolve;
_context12.t1 = request.id;
_context12.next = 7;
return _SigningService["default"].sign(network, payload, publicKey, true, false);
case 7:
_context12.t2 = _context12.sent;
_context12.t3 = {
id: _context12.t1,
result: _context12.t2
};
(0, _context12.t0)(_context12.t3);
case 10:
case "end":
return _context12.stop();
}
}
}, _callee12);
}));
return function (_x15) {
return _ref11.apply(this, arguments);
};
}());
case 20:
case "end":
return _context13.stop();
}
}
}, _callee13);
}));
return function (_x14) {
return _ref9.apply(this, arguments);
};
}()));
case 2:
case "end":
return _context14.stop();
}
}
}, _callee14);
}));
function value(_x13) {
return _value4.apply(this, arguments);
}
return value;
}()
}, {
key: Actions.TRANSFER,
value: function () {
var _value5 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee16(request) {
return _regenerator["default"].wrap(function _callee16$(_context16) {
while (1) {
switch (_context16.prev = _context16.next) {
case 0:
return _context16.abrupt("return", new Promise(function (resolve) {
var _request$payload3 = request.payload,
to = _request$payload3.to,
network = _request$payload3.network,
amount = _request$payload3.amount,
options = _request$payload3.options;
if (!options) options = {};
network = _StoreService["default"].get().state.scatter.settings.networks.find(function (x) {
return x.unique() === _Network["default"].fromJson(network).unique();
});
if (!network) return resolve({
id: request.id,
result: _Error["default"].noNetwork()
});
request.payload.memo = network.blockchain === 'eos' ? options.hasOwnProperty('memo') ? options.memo : '' : '';
request.payload.symbol = options.hasOwnProperty('symbol') ? options.symbol : network.systemToken().symbol;
request.payload.contract = options.hasOwnProperty('contract') ? options.contract : network.systemToken().contract;
_EventService["default"].emit('popout', request).then(
/*#__PURE__*/
function () {
var _ref13 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee15(_ref12) {
var result, account, plugin, token, sent;
return _regenerator["default"].wrap(function _callee15$(_context15) {
while (1) {
switch (_context15.prev = _context15.next) {
case 0:
result = _ref12.result;
if (result) {
_context15.next = 3;
break;
}
return _context15.abrupt("return", resolve({
id: request.id,
result: _Error["default"].signatureError("signature_rejected", "User rejected the transfer request")
}));
case 3:
account = _Account["default"].fromJson(result.account);
plugin = _PluginRepository["default"].plugin(network.blockchain);
token = _Token["default"].fromJson({
contract: request.payload.contract,
blockchain: network.blockchain,
symbol: request.payload.symbol,
decimals: options.hasOwnProperty('decimals') ? options.decimals : network.systemToken().defaultDecimals(),
chainId: account.network().chainId
});
_context15.next = 8;
return _PluginRepository["default"].plugin(network.blockchain).transfer({
account: account,
to: to,
amount: result.amount,
token: token,
memo: request.payload.memo,
promptForSignature: false
})["catch"](function (error) {
return {
error: error
};
});
case 8:
sent = _context15.sent;
_EventService["default"].emit('transfer', request.payload);
resolve({
id: request.id,
result: sent
});
case 11:
case "end":
return _context15.stop();
}
}
}, _callee15);
}));
return function (_x17) {
return _ref13.apply(this, arguments);
};
}());
}));
case 1:
case "end":
return _context16.stop();
}
}
}, _callee16);
}));
function value(_x16) {
return _value5.apply(this, arguments);
}
return value;
}()
}, {
key: Actions.GET_PUBLIC_KEY,
value: function () {
var _value6 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee18(request) {
return _regenerator["default"].wrap(function _callee18$(_context18) {
while (1) {
switch (_context18.prev = _context18.next) {
case 0:
return _context18.abrupt("return", new Promise(function (resolve, reject) {
var badResult = function badResult() {
var msg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Invalid format';
return resolve({
id: request.id,
result: _Error["default"].malicious(msg)
});
};
if (Object.keys(request.payload).length !== 2) return badResult();
if (!request.payload.hasOwnProperty('blockchain')) return badResult();
if (typeof request.payload.blockchain !== 'string') return badResult();
if (!_Blockchains.BlockchainsArray.map(function (x) {
return x.value;
}).includes(request.payload.blockchain)) return badResult('no such blockchain');
_EventService["default"].emit('popout', request).then(
/*#__PURE__*/
function () {
var _ref15 = (0, _asyncToGenerator2["default"])(
/*#__PURE__*/
_regenerator["default"].mark(function _callee17(_ref14) {
var result, keypair, publicKey;
return _regenerator["default"].wrap(function _callee17$(_context17) {
while (1) {
switch (_context17.prev = _context17.next) {
case 0:
result = _ref14.result;
if (result) {
_context17.next = 3;
break;
}
return _context17.abrupt("return", resolve({
id: request.id,
result: _Error["default"].rejected()
}));
case 3:
keypair = _Keypair["default"].fromJson(result.keypair);
publicKey = keypair.publicKeys.find(function (x) {
return x.blockchain === request.payload.blockchain;
}).key;
if (!result.isNew) {
_context17.next = 11;
break;
}
_context17.next = 8;
return _KeyPairService["default"].saveKeyPair(keypair);
case 8:
// TODO: Need to solve this with callbacks to the wrapping wallet
//router.push({name:RouteNames.KEYPAIR, params:{id:keypair.id}});