@aeternity/aepp-sdk
Version:
SDK for the æternity blockchain
652 lines (557 loc) • 24.3 kB
JavaScript
import _merge from "ramda/src/merge";
import _toConsumableArray from "@babel/runtime-corejs3/helpers/toConsumableArray";
import _asyncToGenerator from "@babel/runtime-corejs3/helpers/asyncToGenerator";
import _defineProperty from "@babel/runtime-corejs3/helpers/defineProperty";
var _NOTIFICATIONS, _RESPONSES;
function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); if (enumerableOnly) symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { var _context13; _forEachInstanceProperty(_context13 = ownKeys(Object(source), true)).call(_context13, function (key) { _defineProperty(target, key, source[key]); }); } else if (_Object$getOwnPropertyDescriptors) { _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)); } else { var _context14; _forEachInstanceProperty(_context14 = ownKeys(Object(source))).call(_context14, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } } return target; }
import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
import _Object$getOwnPropertySymbols from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols";
import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
import _Object$getOwnPropertyDescriptor from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor";
import _Object$getOwnPropertyDescriptors from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors";
import _Object$defineProperties from "@babel/runtime-corejs3/core-js-stable/object/define-properties";
import _Object$defineProperty from "@babel/runtime-corejs3/core-js-stable/object/define-property";
import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
import { v4 as uuid } from 'uuid';
import Ae from '../../../ae';
import RpcClient from './rpc-client';
import { getHandler, message, voidFn } from '../helpers';
import { METHODS, RPC_STATUS, VERSION } from '../schema';
var NOTIFICATIONS = (_NOTIFICATIONS = {}, _defineProperty(_NOTIFICATIONS, METHODS.wallet.updateAddress, function (instance) {
return function (_ref) {
var params = _ref.params;
instance.rpcClient.accounts = params;
instance.onAddressChange(params);
};
}), _defineProperty(_NOTIFICATIONS, METHODS.updateNetwork, function (instance) {
return function (msg) {
instance.rpcClient.info.networkId = msg.params.networkId;
instance.onNetworkChange(msg.params);
};
}), _defineProperty(_NOTIFICATIONS, METHODS.closeConnection, function (instance) {
return function (msg) {
instance.disconnectWallet();
instance.onDisconnect(msg.params);
};
}), _NOTIFICATIONS);
var RESPONSES = (_RESPONSES = {}, _defineProperty(_RESPONSES, METHODS.aepp.address, function (instance) {
return function (msg) {
return instance.rpcClient.processResponse(msg);
};
}), _defineProperty(_RESPONSES, METHODS.aepp.connect, function (instance) {
return function (msg) {
if (msg.result) instance.rpcClient.info.status = RPC_STATUS.CONNECTED;
instance.rpcClient.processResponse(msg);
};
}), _defineProperty(_RESPONSES, METHODS.aepp.subscribeAddress, function (instance) {
return function (msg) {
if (msg.result) {
msg.result.address && (instance.rpcClient.accounts = msg.result.address);
msg.result.subscription && (instance.rpcClient.addressSubscription = msg.result.subscription);
}
instance.rpcClient.processResponse(msg, function (_ref2) {
var id = _ref2.id,
result = _ref2.result;
return [result];
});
};
}), _defineProperty(_RESPONSES, METHODS.aepp.sign, function (instance) {
return function (msg) {
instance.rpcClient.processResponse(msg, function (_ref3) {
var id = _ref3.id,
result = _ref3.result;
return [result.signedTransaction || result.transactionHash];
});
};
}), _defineProperty(_RESPONSES, METHODS.aepp.signMessage, function (instance) {
return function (msg) {
instance.rpcClient.processResponse(msg, function (_ref4) {
var id = _ref4.id,
result = _ref4.result;
return [result.signature];
});
};
}), _RESPONSES);
var REQUESTS = {};
var handleMessage = function handleMessage(instance) {
return /*#__PURE__*/function () {
var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(msg) {
return _regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
if (msg.id) {
_context.next = 4;
break;
}
return _context.abrupt("return", getHandler(NOTIFICATIONS, msg, {
debug: instance.debug
})(instance)(msg));
case 4:
if (!Object.prototype.hasOwnProperty.call(instance.rpcClient.callbacks, msg.id)) {
_context.next = 8;
break;
}
return _context.abrupt("return", getHandler(RESPONSES, msg, {
debug: instance.debug
})(instance)(msg));
case 8:
return _context.abrupt("return", getHandler(REQUESTS, msg, {
debug: instance.debug
})(instance)(msg));
case 9:
case "end":
return _context.stop();
}
}
}, _callee);
}));
return function (_x) {
return _ref5.apply(this, arguments);
};
}();
};
/**
* Contain functionality for wallet interaction and connect it to sdk
* @alias module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc
* @function
* @rtype Stamp
* @param {Object} param Init params object
* @param {String=} [param.name] Aepp name
* @param {Function} onAddressChange Call-back function for update address event
* @param {Function} onDisconnect Call-back function for disconnect event
* @param {Function} onNetworkChange Call-back function for update network event
* @param {Object} connection Wallet connection object
* @return {Object}
*/
export default Ae.compose({
init: function init(_ref6) {
var _this = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
var name, _ref6$onAddressChange, onAddressChange, _ref6$onDisconnect, onDisconnect, _ref6$onNetworkChange, onNetworkChange, connection, _ref6$forceValidation, forceValidation, _ref6$debug, debug, eventsHandlers;
return _regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
name = _ref6.name, _ref6$onAddressChange = _ref6.onAddressChange, onAddressChange = _ref6$onAddressChange === void 0 ? voidFn : _ref6$onAddressChange, _ref6$onDisconnect = _ref6.onDisconnect, onDisconnect = _ref6$onDisconnect === void 0 ? voidFn : _ref6$onDisconnect, _ref6$onNetworkChange = _ref6.onNetworkChange, onNetworkChange = _ref6$onNetworkChange === void 0 ? voidFn : _ref6$onNetworkChange, connection = _ref6.connection, _ref6$forceValidation = _ref6.forceValidation, forceValidation = _ref6$forceValidation === void 0 ? false : _ref6$forceValidation, _ref6$debug = _ref6.debug, debug = _ref6$debug === void 0 ? false : _ref6$debug;
eventsHandlers = ['onDisconnect', 'onAddressChange', 'onNetworkChange'];
_this.connection = connection;
_this.name = name;
_this.debug = debug;
if (!connection) {
_context2.next = 8;
break;
}
_context2.next = 8;
return _this.connectToWallet(connection);
case 8:
// Event callbacks
_this.onDisconnect = onDisconnect;
_this.onAddressChange = onAddressChange;
_this.onNetworkChange = onNetworkChange; // validation
_forEachInstanceProperty(eventsHandlers).call(eventsHandlers, function (event) {
if (!forceValidation && typeof _this[event] !== 'function') throw new Error("Call-back for ".concat(event, " must be an function!"));
});
case 12:
case "end":
return _context2.stop();
}
}
}, _callee2);
}))();
},
deepProps: {
Ae: {
defaults: {
walletBroadcast: true
}
}
},
methods: {
sign: function sign() {},
addresses: function addresses() {
var _context3;
if (!this.rpcClient.currentAccount) throw new Error('You are not subscribed for an account.');
return _concatInstanceProperty(_context3 = [this.rpcClient.currentAccount]).call(_context3, _toConsumableArray(_Object$keys(this.rpcClient.accounts.connected)));
},
/**
* Connect to wallet
* @function connectToWallet
* @instance
* @rtype (connection: Object) => void
* @param {Object} connection Wallet connection object
* @return {void}
*/
connectToWallet: function connectToWallet(connection) {
var _this2 = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
return _regeneratorRuntime.wrap(function _callee3$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
if (!(_this2.rpcClient && _this2.rpcClient.isConnected())) {
_context4.next = 2;
break;
}
throw new Error('You are already connected to wallet ' + _this2.rpcClient);
case 2:
_this2.rpcClient = RpcClient(_objectSpread(_objectSpread({
connection: connection,
networkId: _this2.getNetworkId({
force: true
})
}, connection.connectionInfo), {}, {
id: uuid(),
handlers: [handleMessage(_this2), _this2.onDisconnect]
}));
return _context4.abrupt("return", _this2.sendConnectRequest());
case 4:
case "end":
return _context4.stop();
}
}
}, _callee3);
}))();
},
/**
* Disconnect from wallet
* @function disconnectWallet
* @instance
* @rtype (force: Boolean = false) => void
* @param {Boolean} sendDisconnect=false Force sending close connection message
* @return {void}
*/
disconnectWallet: function disconnectWallet() {
var _arguments = arguments,
_this3 = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
var sendDisconnect;
return _regeneratorRuntime.wrap(function _callee4$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
sendDisconnect = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : true;
if (!(!_this3.rpcClient || !_this3.rpcClient.isConnected())) {
_context5.next = 3;
break;
}
throw new Error('You are not connected to Wallet');
case 3:
sendDisconnect && _this3.rpcClient.sendMessage(message(METHODS.closeConnection, {
reason: 'bye'
}), true);
_this3.rpcClient.disconnect();
_this3.rpcClient = null;
case 6:
case "end":
return _context5.stop();
}
}
}, _callee4);
}))();
},
address: function address() {
var _arguments2 = arguments,
_this4 = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
var _ref7, onAccount, current;
return _regeneratorRuntime.wrap(function _callee5$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
_ref7 = _arguments2.length > 0 && _arguments2[0] !== undefined ? _arguments2[0] : {}, onAccount = _ref7.onAccount;
if (!(!_this4.rpcClient || !_this4.rpcClient.isConnected())) {
_context6.next = 3;
break;
}
throw new Error('You are not connected to Wallet');
case 3:
current = _this4.rpcClient.currentAccount;
if (current) {
_context6.next = 6;
break;
}
throw new Error('You are not subscribed for an account.');
case 6:
if (!(onAccount && !_this4.rpcClient.hasAccessToAccount(onAccount))) {
_context6.next = 8;
break;
}
throw new Error("You do not have access to account ".concat(onAccount));
case 8:
return _context6.abrupt("return", onAccount || current);
case 9:
case "end":
return _context6.stop();
}
}
}, _callee5);
}))();
},
/**
* Ask address from wallet
* @function askAddresses
* @instance
* @rtype () => Promise
* @return {Promise} Address from wallet
*/
askAddresses: function askAddresses() {
var _this5 = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
return _regeneratorRuntime.wrap(function _callee6$(_context7) {
while (1) {
switch (_context7.prev = _context7.next) {
case 0:
if (!(!_this5.rpcClient || !_this5.rpcClient.isConnected())) {
_context7.next = 2;
break;
}
throw new Error('You are not connected to Wallet');
case 2:
if (_this5.rpcClient.currentAccount) {
_context7.next = 4;
break;
}
throw new Error('You are not subscribed for an account.');
case 4:
return _context7.abrupt("return", _this5.rpcClient.request(METHODS.aepp.address));
case 5:
case "end":
return _context7.stop();
}
}
}, _callee6);
}))();
},
/**
* Subscribe for addresses from wallet
* @function subscribeAddress
* @instance
* @rtype (type: String, value: String) => Promise
* @param {String} type Type of subscription can be one of ['current'(just for selected account updates), 'connected(all accounts)']
* @param {String} value Subscription action('subscribe'|'unsubscribe')
* @return {Promise} Address from wallet
*/
subscribeAddress: function subscribeAddress(type, value) {
var _this6 = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
return _regeneratorRuntime.wrap(function _callee7$(_context8) {
while (1) {
switch (_context8.prev = _context8.next) {
case 0:
if (!(!_this6.rpcClient || !_this6.rpcClient.isConnected())) {
_context8.next = 2;
break;
}
throw new Error('You are not connected to Wallet');
case 2:
return _context8.abrupt("return", _this6.rpcClient.request(METHODS.aepp.subscribeAddress, {
type: type,
value: value
}));
case 3:
case "end":
return _context8.stop();
}
}
}, _callee7);
}))();
},
/**
* Overwriting of `signTransaction` AE method
* All sdk API which use it will be send notification to wallet and wait for callBack
* @function signTransaction
* @instance
* @rtype (tx: String, options = {}) => Promise
* @return {Promise<String>} Signed transaction
*/
signTransaction: function signTransaction(tx) {
var _arguments3 = arguments,
_this7 = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
var opt;
return _regeneratorRuntime.wrap(function _callee8$(_context9) {
while (1) {
switch (_context9.prev = _context9.next) {
case 0:
opt = _arguments3.length > 1 && _arguments3[1] !== undefined ? _arguments3[1] : {};
if (!(!_this7.rpcClient || !_this7.rpcClient.isConnected())) {
_context9.next = 3;
break;
}
throw new Error('You are not connected to Wallet');
case 3:
if (_this7.rpcClient.currentAccount) {
_context9.next = 5;
break;
}
throw new Error('You are not subscribed for an account.');
case 5:
if (!(opt.onAccount && !_this7.rpcClient.hasAccessToAccount(opt.onAccount))) {
_context9.next = 7;
break;
}
throw new Error("You do not have access to account ".concat(opt.onAccount));
case 7:
return _context9.abrupt("return", _this7.rpcClient.request(METHODS.aepp.sign, _objectSpread(_objectSpread({}, opt), {}, {
tx: tx,
returnSigned: true,
networkId: _this7.getNetworkId()
})));
case 8:
case "end":
return _context9.stop();
}
}
}, _callee8);
}))();
},
/**
* Overwriting of `signMessage` AE method
* All sdk API which use it will be send notification to wallet and wait for callBack
* @function signMessage
* @instance
* @rtype (msg: String, options = {}) => Promise
* @return {Promise<String>} Signed transaction
*/
signMessage: function signMessage(msg) {
var _arguments4 = arguments,
_this8 = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
var opt;
return _regeneratorRuntime.wrap(function _callee9$(_context10) {
while (1) {
switch (_context10.prev = _context10.next) {
case 0:
opt = _arguments4.length > 1 && _arguments4[1] !== undefined ? _arguments4[1] : {};
if (!(!_this8.rpcClient || !_this8.rpcClient.isConnected())) {
_context10.next = 3;
break;
}
throw new Error('You are not connected to Wallet');
case 3:
if (_this8.rpcClient.currentAccount) {
_context10.next = 5;
break;
}
throw new Error('You are not subscribed for an account.');
case 5:
if (!(opt.onAccount && !_this8.rpcClient.hasAccessToAccount(opt.onAccount))) {
_context10.next = 7;
break;
}
throw new Error("You do not have access to account ".concat(opt.onAccount));
case 7:
return _context10.abrupt("return", _this8.rpcClient.request(METHODS.aepp.signMessage, _objectSpread(_objectSpread({}, opt), {}, {
message: msg
})));
case 8:
case "end":
return _context10.stop();
}
}
}, _callee9);
}))();
},
/**
* Send connection request to wallet
* @function sendConnectRequest
* @instance
* @rtype () => Promise
* @return {Promise} Connection response
*/
sendConnectRequest: function sendConnectRequest() {
var _this9 = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
return _regeneratorRuntime.wrap(function _callee10$(_context11) {
while (1) {
switch (_context11.prev = _context11.next) {
case 0:
return _context11.abrupt("return", _this9.rpcClient.request(METHODS.aepp.connect, {
name: _this9.name,
version: VERSION,
networkId: _this9.getNetworkId({
force: true
})
}));
case 1:
case "end":
return _context11.stop();
}
}
}, _callee10);
}))();
},
/**
* Overwriting of `send` AE method
* All sdk API which use it will be send notification to wallet and wait for callBack
* This method will sign, broadcast and wait until transaction will be accepted using rpc communication with wallet
* @function send
* @instance
* @rtype (tx: String, options = {}) => Promise
* @param {String} tx
* @param {Object} [options={}]
* @param {Object} [options.walletBroadcast=true]
* @return {Promise<Object>} Transaction broadcast result
*/
send: function send(tx) {
var _arguments5 = arguments,
_this10 = this;
return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
var options, opt, signed;
return _regeneratorRuntime.wrap(function _callee11$(_context12) {
while (1) {
switch (_context12.prev = _context12.next) {
case 0:
options = _arguments5.length > 1 && _arguments5[1] !== undefined ? _arguments5[1] : {};
if (!(!_this10.rpcClient || !_this10.rpcClient.isConnected())) {
_context12.next = 3;
break;
}
throw new Error('You are not connected to Wallet');
case 3:
if (_this10.rpcClient.currentAccount) {
_context12.next = 5;
break;
}
throw new Error('You are not subscribed for an account.');
case 5:
if (!(options.onAccount && !_this10.rpcClient.hasAccessToAccount(options.onAccount))) {
_context12.next = 7;
break;
}
throw new Error("You do not have access to account ".concat(options.onAccount));
case 7:
opt = _merge(_this10.Ae.defaults, options);
if (opt.walletBroadcast) {
_context12.next = 13;
break;
}
_context12.next = 11;
return _this10.signTransaction(tx, {
onAccount: opt.onAccount
});
case 11:
signed = _context12.sent;
return _context12.abrupt("return", _this10.sendTransaction(signed, opt));
case 13:
return _context12.abrupt("return", _this10.rpcClient.request(METHODS.aepp.sign, {
onAccount: opt.onAccount,
tx: tx,
returnSigned: false,
networkId: _this10.getNetworkId()
}));
case 14:
case "end":
return _context12.stop();
}
}
}, _callee11);
}))();
}
}
});
//# sourceMappingURL=aepp-rpc.js.map