@aeternity/aepp-sdk 8.2.1 → 10.0.0

package/es/channel/index.js

@@ -1,29 +1,3 @@
-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 _forEachInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/for-each";
-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 _reduce from "ramda/src/reduce";
-import _typeof from "@babel/runtime-corejs3/helpers/typeof";
-import _asyncToGenerator from "@babel/runtime-corejs3/helpers/asyncToGenerator";
-import _defineProperty from "@babel/runtime-corejs3/helpers/defineProperty";
-import _slicedToArray from "@babel/runtime-corejs3/helpers/slicedToArray";
-import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
-
-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 _context10; _forEachInstanceProperty(_context10 = ownKeys(Object(source), true)).call(_context10, function (key) { _defineProperty(target, key, source[key]); }); } else if (_Object$getOwnPropertyDescriptors) { _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)); } else { var _context11; _forEachInstanceProperty(_context11 = ownKeys(Object(source))).call(_context11, function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-import _reduceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/reduce";
-import _Object$entries from "@babel/runtime-corejs3/core-js-stable/object/entries";
-import _parseInt from "@babel/runtime-corejs3/core-js-stable/parse-int";
-import _Promise from "@babel/runtime-corejs3/core-js-stable/promise";
-import _JSON$stringify from "@babel/runtime-corejs3/core-js-stable/json/stringify";
-import _setTimeout from "@babel/runtime-corejs3/core-js-stable/set-timeout";
-
 /*
  * ISC License (ISC)
  * Copyright (c) 2018 aeternity developers
@@ -55,14 +29,11 @@ import * as handlers from './handlers';
 import { eventEmitters, status as channelStatus, state as channelState, initialize, enqueueAction, send, channelId, call, disconnect as channelDisconnect, fsmId as channelFsmId } from './internal';
 
 function snakeToPascalObjKeys(obj) {
-  var _context;
-
-  return _reduceInstanceProperty(_context = _Object$entries(obj)).call(_context, function (result, _ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-        key = _ref2[0],
-        val = _ref2[1];
-
-    return _objectSpread(_objectSpread({}, result), {}, _defineProperty({}, snakeToPascal(key), val));
+  return Object.entries(obj).reduce((result, _ref) => {
+    let [key, val] = _ref;
+    return { ...result,
+      [snakeToPascal(key)]: val
+    };
   }, {});
 }
 /**
@@ -121,8 +92,8 @@ function status() {
  */
 
 
-function state() {
-  return _state.apply(this, arguments);
+async function state() {
+  return snakeToPascalObjKeys(await call(this, 'channels.get.offchain_state', {}));
 }
 /**
  * Get current round
@@ -134,40 +105,17 @@ function state() {
  */
 
 
-function _state() {
-  _state = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-    return _regeneratorRuntime.wrap(function _callee2$(_context3) {
-      while (1) {
-        switch (_context3.prev = _context3.next) {
-          case 0:
-            _context3.t0 = snakeToPascalObjKeys;
-            _context3.next = 3;
-            return call(this, 'channels.get.offchain_state', {});
-
-          case 3:
-            _context3.t1 = _context3.sent;
-            return _context3.abrupt("return", (0, _context3.t0)(_context3.t1));
-
-          case 5:
-          case "end":
-            return _context3.stop();
-        }
-      }
-    }, _callee2, this);
-  }));
-  return _state.apply(this, arguments);
-}
-
 function round() {
-  var state = channelState.get(this);
+  const state = channelState.get(this);
 
   if (!state) {
     return null;
   }
 
-  var _unpackTx$tx$encodedT = unpackTx(channelState.get(this)).tx.encodedTx,
-      txType = _unpackTx$tx$encodedT.txType,
-      tx = _unpackTx$tx$encodedT.tx;
+  const {
+    txType,
+    tx
+  } = unpackTx(channelState.get(this)).tx.encodedTx;
 
   switch (txType) {
     case TX_TYPE.channelCreate:
@@ -176,7 +124,7 @@ function round() {
     case TX_TYPE.channelOffChain:
     case TX_TYPE.channelWithdraw:
     case TX_TYPE.channelDeposit:
-      return _parseInt(tx.round, 10);
+      return parseInt(tx.round, 10);
 
     default:
       return null;
@@ -231,28 +179,24 @@ function fsmId() {
 
 
 function update(from, to, amount, sign, metadata) {
-  var _this = this;
-
-  return new _Promise(function (resolve, reject) {
-    enqueueAction(_this, function (channel, state) {
-      return state.handler === handlers.channelOpen;
-    }, function (channel, state) {
+  return new Promise((resolve, reject) => {
+    enqueueAction(this, (channel, state) => state.handler === handlers.channelOpen, (channel, state) => {
       send(channel, {
         jsonrpc: '2.0',
         method: 'channels.update.new',
         params: {
-          from: from,
-          to: to,
-          amount: amount,
+          from,
+          to,
+          amount,
           meta: metadata
         }
       });
       return {
         handler: handlers.awaitingOffChainTx,
         state: {
-          resolve: resolve,
-          reject: reject,
-          sign: sign
+          resolve,
+          reject,
+          sign
         }
       };
     });
@@ -278,8 +222,15 @@ function update(from, to, amount, sign, metadata) {
  */
 
 
-function poi(_x) {
-  return _poi.apply(this, arguments);
+async function poi(_ref2) {
+  let {
+    accounts,
+    contracts
+  } = _ref2;
+  return (await call(this, 'channels.get.poi', {
+    accounts,
+    contracts
+  })).poi;
 }
 /**
  * Get balances
@@ -302,35 +253,10 @@ function poi(_x) {
  */
 
 
-function _poi() {
-  _poi = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_ref3) {
-    var accounts, contracts;
-    return _regeneratorRuntime.wrap(function _callee3$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            accounts = _ref3.accounts, contracts = _ref3.contracts;
-            _context4.next = 3;
-            return call(this, 'channels.get.poi', {
-              accounts: accounts,
-              contracts: contracts
-            });
-
-          case 3:
-            return _context4.abrupt("return", _context4.sent.poi);
-
-          case 4:
-          case "end":
-            return _context4.stop();
-        }
-      }
-    }, _callee3, this);
-  }));
-  return _poi.apply(this, arguments);
-}
-
-function balances(_x2) {
-  return _balances.apply(this, arguments);
+async function balances(accounts) {
+  return Object.fromEntries((await call(this, 'channels.get.balances', {
+    accounts
+  })).map(item => [item.account, item.balance]));
 }
 /**
  * Leave channel
@@ -352,45 +278,9 @@ function balances(_x2) {
  */
 
 
-function _balances() {
-  _balances = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(accounts) {
-    return _regeneratorRuntime.wrap(function _callee4$(_context5) {
-      while (1) {
-        switch (_context5.prev = _context5.next) {
-          case 0:
-            _context5.t0 = _reduce;
-
-            _context5.t1 = function (acc, item) {
-              return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, item.account, item.balance));
-            };
-
-            _context5.t2 = {};
-            _context5.next = 5;
-            return call(this, 'channels.get.balances', {
-              accounts: accounts
-            });
-
-          case 5:
-            _context5.t3 = _context5.sent;
-            return _context5.abrupt("return", (0, _context5.t0)(_context5.t1, _context5.t2, _context5.t3));
-
-          case 7:
-          case "end":
-            return _context5.stop();
-        }
-      }
-    }, _callee4, this);
-  }));
-  return _balances.apply(this, arguments);
-}
-
 function leave() {
-  var _this2 = this;
-
-  return new _Promise(function (resolve, reject) {
-    enqueueAction(_this2, function (channel, state) {
-      return state.handler === handlers.channelOpen;
-    }, function (channel, state) {
+  return new Promise((resolve, reject) => {
+    enqueueAction(this, (channel, state) => state.handler === handlers.channelOpen, (channel, state) => {
       send(channel, {
         jsonrpc: '2.0',
         method: 'channels.leave',
@@ -399,8 +289,8 @@ function leave() {
       return {
         handler: handlers.awaitingLeave,
         state: {
-          resolve: resolve,
-          reject: reject
+          resolve,
+          reject
         }
       };
     });
@@ -421,12 +311,8 @@ function leave() {
 
 
 function shutdown(sign) {
-  var _this3 = this;
-
-  return new _Promise(function (resolve, reject) {
-    enqueueAction(_this3, function (channel, state) {
-      return state.handler === handlers.channelOpen;
-    }, function (channel, state) {
+  return new Promise((resolve, reject) => {
+    enqueueAction(this, (channel, state) => state.handler === handlers.channelOpen, (channel, state) => {
       send(channel, {
         jsonrpc: '2.0',
         method: 'channels.shutdown',
@@ -435,9 +321,9 @@ function shutdown(sign) {
       return {
         handler: handlers.awaitingShutdownTx,
         state: {
-          sign: sign,
-          resolve: resolve,
-          reject: reject
+          sign,
+          resolve,
+          reject
         }
       };
     });
@@ -473,7 +359,8 @@ function shutdown(sign) {
  * @param {Number} amount - Amount of tokens to withdraw
  * @param {Function} sign - Function which verifies and signs withdraw transaction
  * @param {Object} [callbacks]
- * @param {Function} [callbacks.onOnChainTx] - Called when withdraw transaction has been posted on chain
+ * @param {Function} [callbacks.onOnChainTx] - Called when withdraw transaction has been posted
+ * on chain
  * @param {Function} [callbacks.onOwnWithdrawLocked]
  * @param {Function} [callbacks.onWithdrawLocked]
  * @return {Promise<Object>}
@@ -492,33 +379,29 @@ function shutdown(sign) {
 
 
 function withdraw(amount, sign) {
-  var _this4 = this;
-
-  var _ref4 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-      onOnChainTx = _ref4.onOnChainTx,
-      onOwnWithdrawLocked = _ref4.onOwnWithdrawLocked,
-      onWithdrawLocked = _ref4.onWithdrawLocked;
-
-  return new _Promise(function (resolve, reject) {
-    enqueueAction(_this4, function (channel, state) {
-      return state.handler === handlers.channelOpen;
-    }, function (channel, state) {
+  let {
+    onOnChainTx,
+    onOwnWithdrawLocked,
+    onWithdrawLocked
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return new Promise((resolve, reject) => {
+    enqueueAction(this, (channel, state) => state.handler === handlers.channelOpen, (channel, state) => {
       send(channel, {
         jsonrpc: '2.0',
         method: 'channels.withdraw',
         params: {
-          amount: amount
+          amount
         }
       });
       return {
         handler: handlers.awaitingWithdrawTx,
         state: {
-          sign: sign,
-          resolve: resolve,
-          reject: reject,
-          onOnChainTx: onOnChainTx,
-          onOwnWithdrawLocked: onOwnWithdrawLocked,
-          onWithdrawLocked: onWithdrawLocked
+          sign,
+          resolve,
+          reject,
+          onOnChainTx,
+          onOwnWithdrawLocked,
+          onWithdrawLocked
         }
       };
     });
@@ -554,7 +437,8 @@ function withdraw(amount, sign) {
  * @param {Number} amount - Amount of tokens to deposit
  * @param {Function} sign - Function which verifies and signs deposit transaction
  * @param {Object} [callbacks]
- * @param {Function} [callbacks.onOnChainTx] - Called when deposit transaction has been posted on chain
+ * @param {Function} [callbacks.onOnChainTx] - Called when deposit transaction has been posted
+ * on chain
  * @param {Function} [callbacks.onOwnDepositLocked]
  * @param {Function} [callbacks.onDepositLocked]
  * @return {Promise<Object>}
@@ -574,33 +458,29 @@ function withdraw(amount, sign) {
 
 
 function deposit(amount, sign) {
-  var _this5 = this;
-
-  var _ref5 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-      onOnChainTx = _ref5.onOnChainTx,
-      onOwnDepositLocked = _ref5.onOwnDepositLocked,
-      onDepositLocked = _ref5.onDepositLocked;
-
-  return new _Promise(function (resolve, reject) {
-    enqueueAction(_this5, function (channel, state) {
-      return state.handler === handlers.channelOpen;
-    }, function (channel, state) {
+  let {
+    onOnChainTx,
+    onOwnDepositLocked,
+    onDepositLocked
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return new Promise((resolve, reject) => {
+    enqueueAction(this, (channel, state) => state.handler === handlers.channelOpen, (channel, state) => {
       send(channel, {
         jsonrpc: '2.0',
         method: 'channels.deposit',
         params: {
-          amount: amount
+          amount
         }
       });
       return {
         handler: handlers.awaitingDepositTx,
         state: {
-          sign: sign,
-          resolve: resolve,
-          reject: reject,
-          onOnChainTx: onOnChainTx,
-          onOwnDepositLocked: onOwnDepositLocked,
-          onDepositLocked: onDepositLocked
+          sign,
+          resolve,
+          reject,
+          onOnChainTx,
+          onOwnDepositLocked,
+          onDepositLocked
         }
       };
     });
@@ -640,25 +520,23 @@ function deposit(amount, sign) {
  */
 
 
-function createContract(_ref6, sign) {
-  var _this6 = this;
-
-  var code = _ref6.code,
-      callData = _ref6.callData,
-      deposit = _ref6.deposit,
-      vmVersion = _ref6.vmVersion,
-      abiVersion = _ref6.abiVersion;
-  return new _Promise(function (resolve, reject) {
-    enqueueAction(_this6, function (channel, state) {
-      return state.handler === handlers.channelOpen;
-    }, function (channel, state) {
+function createContract(_ref3, sign) {
+  let {
+    code,
+    callData,
+    deposit,
+    vmVersion,
+    abiVersion
+  } = _ref3;
+  return new Promise((resolve, reject) => {
+    enqueueAction(this, (channel, state) => state.handler === handlers.channelOpen, (channel, state) => {
       send(channel, {
         jsonrpc: '2.0',
         method: 'channels.update.new_contract',
         params: {
-          code: code,
+          code,
           call_data: callData,
-          deposit: deposit,
+          deposit,
           vm_version: vmVersion,
           abi_version: abiVersion
         }
@@ -666,9 +544,9 @@ function createContract(_ref6, sign) {
       return {
         handler: handlers.awaitingNewContractTx,
         state: {
-          sign: sign,
-          resolve: resolve,
-          reject: reject
+          sign,
+          resolve,
+          reject
         }
       };
     });
@@ -712,22 +590,20 @@ function createContract(_ref6, sign) {
  */
 
 
-function callContract(_ref7, sign) {
-  var _this7 = this;
-
-  var amount = _ref7.amount,
-      callData = _ref7.callData,
-      contract = _ref7.contract,
-      abiVersion = _ref7.abiVersion;
-  return new _Promise(function (resolve, reject) {
-    enqueueAction(_this7, function (channel, state) {
-      return state.handler === handlers.channelOpen;
-    }, function (channel, state) {
+function callContract(_ref4, sign) {
+  let {
+    amount,
+    callData,
+    contract,
+    abiVersion
+  } = _ref4;
+  return new Promise((resolve, reject) => {
+    enqueueAction(this, (channel, state) => state.handler === handlers.channelOpen, (channel, state) => {
       send(channel, {
         jsonrpc: '2.0',
         method: 'channels.update.call_contract',
         params: {
-          amount: amount,
+          amount,
           call_data: callData,
           contract_id: contract,
           abi_version: abiVersion
@@ -736,9 +612,9 @@ function callContract(_ref7, sign) {
       return {
         handler: handlers.awaitingCallContractUpdateTx,
         state: {
-          resolve: resolve,
-          reject: reject,
-          sign: sign
+          resolve,
+          reject,
+          sign
         }
       };
     });
@@ -773,45 +649,40 @@ function callContract(_ref7, sign) {
  */
 
 
-function forceProgress(_ref8, sign) {
-  var _this8 = this;
-
-  var amount = _ref8.amount,
-      callData = _ref8.callData,
-      contract = _ref8.contract,
-      abiVersion = _ref8.abiVersion,
-      _ref8$gas = _ref8.gas,
-      gas = _ref8$gas === void 0 ? 1000000 : _ref8$gas,
-      _ref8$gasPrice = _ref8.gasPrice,
-      gasPrice = _ref8$gasPrice === void 0 ? 1000000000 : _ref8$gasPrice,
-      nonce = _ref8.nonce;
-
-  var _ref9 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-      onOnChainTx = _ref9.onOnChainTx;
-
-  return new _Promise(function (resolve, reject) {
-    enqueueAction(_this8, function (channel, state) {
-      return state.handler === handlers.channelOpen;
-    }, function (channel, state) {
+function forceProgress(_ref5, sign) {
+  let {
+    amount,
+    callData,
+    contract,
+    abiVersion,
+    gas = 1000000,
+    gasPrice = 1000000000,
+    nonce
+  } = _ref5;
+  let {
+    onOnChainTx
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return new Promise((resolve, reject) => {
+    enqueueAction(this, (channel, state) => state.handler === handlers.channelOpen, (channel, state) => {
       send(channel, {
         jsonrpc: '2.0',
         method: 'channels.force_progress',
         params: {
-          amount: amount,
+          amount,
           call_data: callData,
           contract_id: contract,
           abi_version: abiVersion,
           gas_price: gasPrice,
-          gas: gas
+          gas
         }
       });
       return {
         handler: handlers.awaitingCallContractForceProgressUpdate,
         state: {
-          resolve: resolve,
-          reject: reject,
-          sign: sign,
-          onOnChainTx: onOnChainTx
+          resolve,
+          reject,
+          sign,
+          onOnChainTx
         }
       };
     });
@@ -846,8 +717,19 @@ function forceProgress(_ref8, sign) {
   */
 
 
-function callContractStatic(_x3) {
-  return _callContractStatic.apply(this, arguments);
+async function callContractStatic(_ref6) {
+  let {
+    amount,
+    callData,
+    contract,
+    abiVersion
+  } = _ref6;
+  return snakeToPascalObjKeys(await call(this, 'channels.dry_run.call_contract', {
+    amount,
+    call_data: callData,
+    contract_id: contract,
+    abi_version: abiVersion
+  }));
 }
 /**
  * Get contract call result
@@ -870,39 +752,17 @@ function callContractStatic(_x3) {
  */
 
 
-function _callContractStatic() {
-  _callContractStatic = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref10) {
-    var amount, callData, contract, abiVersion;
-    return _regeneratorRuntime.wrap(function _callee5$(_context6) {
-      while (1) {
-        switch (_context6.prev = _context6.next) {
-          case 0:
-            amount = _ref10.amount, callData = _ref10.callData, contract = _ref10.contract, abiVersion = _ref10.abiVersion;
-            _context6.t0 = snakeToPascalObjKeys;
-            _context6.next = 4;
-            return call(this, 'channels.dry_run.call_contract', {
-              amount: amount,
-              call_data: callData,
-              contract_id: contract,
-              abi_version: abiVersion
-            });
-
-          case 4:
-            _context6.t1 = _context6.sent;
-            return _context6.abrupt("return", (0, _context6.t0)(_context6.t1));
-
-          case 6:
-          case "end":
-            return _context6.stop();
-        }
-      }
-    }, _callee5, this);
+async function getContractCall(_ref7) {
+  let {
+    caller,
+    contract,
+    round
+  } = _ref7;
+  return snakeToPascalObjKeys(await call(this, 'channels.get.contract_call', {
+    caller_id: caller,
+    contract_id: contract,
+    round
   }));
-  return _callContractStatic.apply(this, arguments);
-}
-
-function getContractCall(_x4) {
-  return _getContractCall.apply(this, arguments);
 }
 /**
  * Get contract latest state
@@ -917,38 +777,13 @@ function getContractCall(_x4) {
  */
 
 
-function _getContractCall() {
-  _getContractCall = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(_ref11) {
-    var caller, contract, round;
-    return _regeneratorRuntime.wrap(function _callee6$(_context7) {
-      while (1) {
-        switch (_context7.prev = _context7.next) {
-          case 0:
-            caller = _ref11.caller, contract = _ref11.contract, round = _ref11.round;
-            _context7.t0 = snakeToPascalObjKeys;
-            _context7.next = 4;
-            return call(this, 'channels.get.contract_call', {
-              caller_id: caller,
-              contract_id: contract,
-              round: round
-            });
-
-          case 4:
-            _context7.t1 = _context7.sent;
-            return _context7.abrupt("return", (0, _context7.t0)(_context7.t1));
-
-          case 6:
-          case "end":
-            return _context7.stop();
-        }
-      }
-    }, _callee6, this);
-  }));
-  return _getContractCall.apply(this, arguments);
-}
-
-function getContractState(_x5) {
-  return _getContractState.apply(this, arguments);
+async function getContractState(contract) {
+  const result = await call(this, 'channels.get.contract', {
+    pubkey: contract
+  });
+  return snakeToPascalObjKeys({ ...result,
+    contract: snakeToPascalObjKeys(result.contract)
+  });
 }
 /**
  * Clean up all locally stored contract calls
@@ -962,41 +797,9 @@ function getContractState(_x5) {
  */
 
 
-function _getContractState() {
-  _getContractState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(contract) {
-    var result;
-    return _regeneratorRuntime.wrap(function _callee7$(_context8) {
-      while (1) {
-        switch (_context8.prev = _context8.next) {
-          case 0:
-            _context8.next = 2;
-            return call(this, 'channels.get.contract', {
-              pubkey: contract
-            });
-
-          case 2:
-            result = _context8.sent;
-            return _context8.abrupt("return", snakeToPascalObjKeys(_objectSpread(_objectSpread({}, result), {}, {
-              contract: snakeToPascalObjKeys(result.contract)
-            })));
-
-          case 4:
-          case "end":
-            return _context8.stop();
-        }
-      }
-    }, _callee7, this);
-  }));
-  return _getContractState.apply(this, arguments);
-}
-
 function cleanContractCalls() {
-  var _this9 = this;
-
-  return new _Promise(function (resolve, reject) {
-    enqueueAction(_this9, function (channel, state) {
-      return state.handler === handlers.channelOpen;
-    }, function (channel, state) {
+  return new Promise((resolve, reject) => {
+    enqueueAction(this, (channel, state) => state.handler === handlers.channelOpen, (channel, state) => {
       send(channel, {
         jsonrpc: '2.0',
         method: 'channels.clean_contract_calls',
@@ -1005,8 +808,8 @@ function cleanContractCalls() {
       return {
         handler: handlers.awaitingCallsPruned,
         state: {
-          resolve: resolve,
-          reject: reject
+          resolve,
+          reject
         }
       };
     });
@@ -1031,35 +834,28 @@ function cleanContractCalls() {
 
 
 function sendMessage(message, recipient) {
-  var _this10 = this;
+  let info = message;
 
-  var info = message;
-
-  if (_typeof(message) === 'object') {
-    info = _JSON$stringify(message);
+  if (typeof message === 'object') {
+    info = JSON.stringify(message);
   }
 
-  var doSend = function doSend(channel) {
-    return send(channel, {
-      jsonrpc: '2.0',
-      method: 'channels.message',
-      params: {
-        info: info,
-        to: recipient
-      }
-    });
-  };
+  const doSend = channel => send(channel, {
+    jsonrpc: '2.0',
+    method: 'channels.message',
+    params: {
+      info,
+      to: recipient
+    }
+  });
 
   if (this.status() === 'connecting') {
-    var onStatusChanged = function onStatusChanged(status) {
+    const onStatusChanged = status => {
       if (status !== 'connecting') {
         // For some reason we can't immediately send a message when connection is
         // established. Thus we wait 500ms which seems to work.
-        _setTimeout(function () {
-          return doSend(_this10);
-        }, 500);
-
-        _this10.off('statusChanged', onStatusChanged);
+        setTimeout(() => doSend(this), 500);
+        this.off('statusChanged', onStatusChanged);
       }
     };
 
@@ -1069,8 +865,13 @@ function sendMessage(message, recipient) {
   }
 }
 
-function reconnect(_x6, _x7) {
-  return _reconnect.apply(this, arguments);
+async function reconnect(options, txParams) {
+  const {
+    sign
+  } = options;
+  return Channel({ ...options,
+    reconnectTx: await sign('reconnect', buildTx(txParams, TX_TYPE.channelReconnect).tx)
+  });
 }
 /**
  * Channel
@@ -1084,23 +885,42 @@ function reconnect(_x6, _x7) {
  * @param {String} options.initiatorId - Initiator's public key
  * @param {String} options.responderId - Responder's public key
  * @param {Number} options.pushAmount - Initial deposit in favour of the responder by the initiator
- * @param {Number} options.initiatorAmount - Amount of tokens the initiator has committed to the channel
- * @param {Number} options.responderAmount - Amount of tokens the responder has committed to the channel
+ * @param {Number} options.initiatorAmount - Amount of tokens the initiator has committed to
+ * the channel
+ * @param {Number} options.responderAmount - Amount of tokens the responder has committed to
+ * the channel
  * @param {Number} options.channelReserve - The minimum amount both peers need to maintain
  * @param {Number} [options.ttl] - Minimum block height to include the channel_create_tx
  * @param {String} options.host - Host of the responder's node
  * @param {Number} options.port - The port of the responders node
  * @param {Number} options.lockPeriod - Amount of blocks for disputing a solo close
- * @param {Number} [options.existingChannelId] - Existing channel id (required if reestablishing a channel)
- * @param {Number} [options.offchainTx] - Offchain transaction (required if reestablishing a channel)
- * @param {Number} [options.timeoutIdle] - The time waiting for a new event to be initiated (default: 600000)
- * @param {Number} [options.timeoutFundingCreate] - The time waiting for the initiator to produce the create channel transaction after the noise session had been established (default: 120000)
- * @param {Number} [options.timeoutFundingSign] - The time frame the other client has to sign an off-chain update after our client had initiated and signed it. This applies only for double signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc. (default: 120000)
- * @param {Number} [options.timeoutFundingLock] - The time frame the other client has to confirm an on-chain transaction reaching maturity (passing minimum depth) after the local node has detected this. This applies only for double signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc. (default: 360000)
- * @param {Number} [options.timeoutSign] - The time frame the client has to return a signed off-chain update or to decline it. This applies for all off-chain updates (default: 500000)
- * @param {Number} [options.timeoutAccept] - The time frame the other client has to react to an event. This applies for all off-chain updates that are not meant to land on-chain, as well as some special cases: opening a noise connection, mutual closing acknowledgement and reestablishing an existing channel (default: 120000)
- * @param {Number} [options.timeoutInitialized] - the time frame the responder has to accept an incoming noise session. Applicable only for initiator (default: timeout_accept's value)
- * @param {Number} [options.timeoutAwaitingOpen] - The time frame the initiator has to start an outgoing noise session to the responder's node. Applicable only for responder (default: timeout_idle's value)
+ * @param {Number} [options.existingChannelId] - Existing channel id (required if reestablishing a
+ * channel)
+ * @param {Number} [options.offchainTx] - Offchain transaction (required if reestablishing
+ * a channel)
+ * @param {Number} [options.timeoutIdle] - The time waiting for a new event to be initiated
+ * (default: 600000)
+ * @param {Number} [options.timeoutFundingCreate] - The time waiting for the initiator to produce
+ * the create channel transaction after the noise session had been established (default: 120000)
+ * @param {Number} [options.timeoutFundingSign] - The time frame the other client has to sign an
+ * off-chain update after our client had initiated and signed it. This applies only for double
+ * signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc.
+ * (default: 120000)
+ * @param {Number} [options.timeoutFundingLock] - The time frame the other client has to confirm an
+ * on-chain transaction reaching maturity (passing minimum depth) after the local node has detected
+ * this. This applies only for double signed on-chain intended updates: channel create transaction,
+ * deposit, withdrawal and etc. (default: 360000)
+ * @param {Number} [options.timeoutSign] - The time frame the client has to return a signed
+ * off-chain update or to decline it. This applies for all off-chain updates (default: 500000)
+ * @param {Number} [options.timeoutAccept] - The time frame the other client has to react to an
+ * event. This applies for all off-chain updates that are not meant to land on-chain, as well as
+ * some special cases: opening a noise connection, mutual closing acknowledgement and
+ * reestablishing an existing channel (default: 120000)
+ * @param {Number} [options.timeoutInitialized] - the time frame the responder has to accept an
+ * incoming noise session. Applicable only for initiator (default: timeout_accept's value)
+ * @param {Number} [options.timeoutAwaitingOpen] - The time frame the initiator has to start an
+ * outgoing noise session to the responder's node. Applicable only for responder (default:
+ * timeout_idle's value)
  * @param {Number} [options.debug=false] - Log websocket communication
  * @param {Function} options.sign - Function which verifies and signs transactions
  * @return {Promise<Object>} Channel instance
@@ -1122,85 +942,38 @@ function reconnect(_x6, _x7) {
  */
 
 
-function _reconnect() {
-  _reconnect = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(options, txParams) {
-    var sign;
-    return _regeneratorRuntime.wrap(function _callee8$(_context9) {
-      while (1) {
-        switch (_context9.prev = _context9.next) {
-          case 0:
-            sign = options.sign;
-            _context9.t0 = Channel;
-            _context9.t1 = _objectSpread;
-            _context9.t2 = _objectSpread({}, options);
-            _context9.t3 = {};
-            _context9.next = 7;
-            return sign('reconnect', buildTx(txParams, TX_TYPE.channelReconnect).tx);
-
-          case 7:
-            _context9.t4 = _context9.sent;
-            _context9.t5 = {
-              reconnectTx: _context9.t4
-            };
-            _context9.t6 = (0, _context9.t1)(_context9.t2, _context9.t3, _context9.t5);
-            return _context9.abrupt("return", (0, _context9.t0)(_context9.t6));
-
-          case 11:
-          case "end":
-            return _context9.stop();
-        }
-      }
-    }, _callee8);
-  }));
-  return _reconnect.apply(this, arguments);
-}
-
-var Channel = AsyncInit.compose({
-  init: function init(options) {
-    var _this11 = this;
-
-    return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      return _regeneratorRuntime.wrap(function _callee$(_context2) {
-        while (1) {
-          switch (_context2.prev = _context2.next) {
-            case 0:
-              initialize(_this11, options);
-
-            case 1:
-            case "end":
-              return _context2.stop();
-          }
-        }
-      }, _callee);
-    }))();
+const Channel = AsyncInit.compose({
+  async init(options) {
+    initialize(this, options);
   },
+
   methods: {
-    on: on,
-    off: off,
-    status: status,
-    state: state,
-    round: round,
-    id: id,
-    fsmId: fsmId,
-    update: update,
-    poi: poi,
-    balances: balances,
-    leave: leave,
-    shutdown: shutdown,
-    sendMessage: sendMessage,
-    withdraw: withdraw,
-    deposit: deposit,
-    createContract: createContract,
-    callContract: callContract,
-    callContractStatic: callContractStatic,
-    getContractCall: getContractCall,
-    getContractState: getContractState,
-    disconnect: disconnect,
-    cleanContractCalls: cleanContractCalls,
-    forceProgress: forceProgress
+    on,
+    off,
+    status,
+    state,
+    round,
+    id,
+    fsmId,
+    update,
+    poi,
+    balances,
+    leave,
+    shutdown,
+    sendMessage,
+    withdraw,
+    deposit,
+    createContract,
+    callContract,
+    callContractStatic,
+    getContractCall,
+    getContractState,
+    disconnect,
+    cleanContractCalls,
+    forceProgress
   },
   statics: {
-    reconnect: reconnect
+    reconnect
   }
 });
 export default Channel;