@aeternity/aepp-sdk 8.2.1 → 10.0.0

package/es/utils/aepp-wallet-communication/rpc/aepp-rpc.js

@@ -1,130 +1,94 @@
-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";
+/**
+ * RPC handler for AEPP side
+ *
+ * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc
+ * @export AeppRpc
+ * @example
+ * import ContentScriptBridge
+ * from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc'
+ */
 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;
+const NOTIFICATIONS = {
+  [METHODS.wallet.updateAddress]: instance => _ref => {
+    let {
+      params
+    } = _ref;
     instance.rpcClient.accounts = params;
     instance.onAddressChange(params);
-  };
-}), _defineProperty(_NOTIFICATIONS, METHODS.updateNetwork, function (instance) {
-  return function (msg) {
+  },
+  [METHODS.updateNetwork]: instance => msg => {
     instance.rpcClient.info.networkId = msg.params.networkId;
     instance.onNetworkChange(msg.params);
-  };
-}), _defineProperty(_NOTIFICATIONS, METHODS.closeConnection, function (instance) {
-  return function (msg) {
+  },
+  [METHODS.closeConnection]: instance => 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) {
+  }
+};
+const RESPONSES = {
+  [METHODS.aepp.address]: instance => msg => instance.rpcClient.processResponse(msg),
+  [METHODS.aepp.connect]: instance => 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) {
+  },
+  [METHODS.aepp.subscribeAddress]: instance => msg => {
     if (msg.result) {
-      msg.result.address && (instance.rpcClient.accounts = msg.result.address);
-      msg.result.subscription && (instance.rpcClient.addressSubscription = msg.result.subscription);
+      if (msg.result.address) {
+        instance.rpcClient.accounts = msg.result.address;
+      }
+
+      if (msg.result.subscription) {
+        instance.rpcClient.addressSubscription = msg.result.subscription;
+      }
     }
 
-    instance.rpcClient.processResponse(msg, function (_ref2) {
-      var id = _ref2.id,
-          result = _ref2.result;
+    instance.rpcClient.processResponse(msg, _ref2 => {
+      let {
+        id,
+        result
+      } = _ref2;
       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;
+  },
+  [METHODS.aepp.sign]: instance => msg => {
+    instance.rpcClient.processResponse(msg, _ref3 => {
+      let {
+        id,
+        result
+      } = _ref3;
       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;
+  },
+  [METHODS.aepp.signMessage]: instance => msg => {
+    instance.rpcClient.processResponse(msg, _ref4 => {
+      let {
+        id,
+        result
+      } = _ref4;
       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);
-    };
-  }();
+  }
+};
+const REQUESTS = {};
+
+const handleMessage = instance => async msg => {
+  if (!msg.id) {
+    return getHandler(NOTIFICATIONS, msg, {
+      debug: instance.debug
+    })(instance)(msg);
+  } else if (Object.prototype.hasOwnProperty.call(instance.rpcClient.callbacks, msg.id)) {
+    return getHandler(RESPONSES, msg, {
+      debug: instance.debug
+    })(instance)(msg);
+  } else {
+    return getHandler(REQUESTS, msg, {
+      debug: instance.debug
+    })(instance)(msg);
+  }
 };
 /**
  * Contain functionality for wallet interaction and connect it to sdk
@@ -142,48 +106,36 @@ var handleMessage = function handleMessage(instance) {
 
 
 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);
-    }))();
+  async init(_ref5) {
+    let {
+      name,
+      onAddressChange = voidFn,
+      onDisconnect = voidFn,
+      onNetworkChange = voidFn,
+      connection,
+      forceValidation = false,
+      debug = false
+    } = _ref5;
+    const eventsHandlers = ['onDisconnect', 'onAddressChange', 'onNetworkChange'];
+    this.connection = connection;
+    this.name = name;
+    this.debug = debug;
+
+    if (connection) {
+      // Init RPCClient
+      await this.connectToWallet(connection);
+    } // Event callbacks
+
+
+    this.onDisconnect = onDisconnect;
+    this.onAddressChange = onAddressChange;
+    this.onNetworkChange = onNetworkChange; // validation
+
+    eventsHandlers.forEach(event => {
+      if (!forceValidation && typeof this[event] !== 'function') throw new Error(`Call-back for ${event} must be an function!`);
+    });
   },
+
   deepProps: {
     Ae: {
       defaults: {
@@ -192,12 +144,11 @@ export default Ae.compose({
     }
   },
   methods: {
-    sign: function sign() {},
-    addresses: function addresses() {
-      var _context3;
+    sign() {},
 
+    addresses() {
       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)));
+      return [this.rpcClient.currentAccount, ...Object.keys(this.rpcClient.accounts.connected)];
     },
 
     /**
@@ -208,40 +159,18 @@ export default Ae.compose({
      * @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);
-      }))();
+    async connectToWallet(connection) {
+      if (this.rpcClient && this.rpcClient.isConnected()) throw new Error('You are already connected to wallet ' + this.rpcClient);
+      this.rpcClient = RpcClient({
+        connection,
+        networkId: this.getNetworkId({
+          force: true
+        }),
+        ...connection.connectionInfo,
+        id: uuid(),
+        handlers: [handleMessage(this), this.onDisconnect]
+      });
+      return this.sendConnectRequest();
     },
 
     /**
@@ -252,90 +181,25 @@ export default Ae.compose({
      * @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);
-      }))();
+    async disconnectWallet() {
+      let sendDisconnect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet');
+      sendDisconnect && this.rpcClient.sendMessage(message(METHODS.closeConnection, {
+        reason: 'bye'
+      }), true);
+      this.rpcClient.disconnect();
+      this.rpcClient = null;
     },
-    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);
-      }))();
+    async address() {
+      let {
+        onAccount
+      } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet');
+      const current = this.rpcClient.currentAccount;
+      if (!current) throw new Error('You are not subscribed for an account.');
+      if (onAccount && !this.rpcClient.hasAccessToAccount(onAccount)) throw new Error(`You do not have access to account ${onAccount}`);
+      return onAccount || current;
     },
 
     /**
@@ -345,39 +209,10 @@ export default Ae.compose({
      * @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);
-      }))();
+    async askAddresses() {
+      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet');
+      if (!this.rpcClient.currentAccount) throw new Error('You are not subscribed for an account.');
+      return this.rpcClient.request(METHODS.aepp.address);
     },
 
     /**
@@ -385,38 +220,16 @@ export default Ae.compose({
      * @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} type Should be one of 'current' (the selected account), 'connected' (all)
      * @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);
-      }))();
+    async subscribeAddress(type, value) {
+      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet');
+      return this.rpcClient.request(METHODS.aepp.subscribeAddress, {
+        type,
+        value
+      });
     },
 
     /**
@@ -427,55 +240,16 @@ export default Ae.compose({
      * @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);
-      }))();
+    async signTransaction(tx) {
+      let opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet');
+      if (!this.rpcClient.currentAccount) throw new Error('You are not subscribed for an account.');
+      if (opt.onAccount && !this.rpcClient.hasAccessToAccount(opt.onAccount)) throw new Error(`You do not have access to account ${opt.onAccount}`);
+      return this.rpcClient.request(METHODS.aepp.sign, { ...opt,
+        tx,
+        returnSigned: true,
+        networkId: this.getNetworkId()
+      });
     },
 
     /**
@@ -486,53 +260,14 @@ export default Ae.compose({
      * @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);
-      }))();
+    async signMessage(msg) {
+      let opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet');
+      if (!this.rpcClient.currentAccount) throw new Error('You are not subscribed for an account.');
+      if (opt.onAccount && !this.rpcClient.hasAccessToAccount(opt.onAccount)) throw new Error(`You do not have access to account ${opt.onAccount}`);
+      return this.rpcClient.request(METHODS.aepp.signMessage, { ...opt,
+        message: msg
+      });
     },
 
     /**
@@ -542,35 +277,21 @@ export default Ae.compose({
      * @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);
-      }))();
+    async sendConnectRequest() {
+      return this.rpcClient.request(METHODS.aepp.connect, {
+        name: this.name,
+        version: VERSION,
+        networkId: this.getNetworkId({
+          force: true
+        })
+      });
     },
 
     /**
      * 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
+     * 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
@@ -579,74 +300,30 @@ export default Ae.compose({
      * @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()
-                }));
+    async send(tx) {
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet');
+      if (!this.rpcClient.currentAccount) throw new Error('You are not subscribed for an account.');
+      if (options.onAccount && !this.rpcClient.hasAccessToAccount(options.onAccount)) throw new Error(`You do not have access to account ${options.onAccount}`);
+      const opt = { ...this.Ae.defaults,
+        ...options
+      };
+
+      if (!opt.walletBroadcast) {
+        const signed = await this.signTransaction(tx, {
+          onAccount: opt.onAccount
+        });
+        return this.sendTransaction(signed, opt);
+      }
 
-              case 14:
-              case "end":
-                return _context12.stop();
-            }
-          }
-        }, _callee11);
-      }))();
+      return this.rpcClient.request(METHODS.aepp.sign, {
+        onAccount: opt.onAccount,
+        tx,
+        returnSigned: false,
+        networkId: this.getNetworkId()
+      });
     }
+
   }
 });
 //# sourceMappingURL=aepp-rpc.js.map