@aeternity/aepp-sdk 8.2.1 → 10.0.0

package/es/channel/handlers.js

@@ -1,12 +1,3 @@
-import _slicedToArray from "@babel/runtime-corejs3/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime-corejs3/helpers/asyncToGenerator";
-import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
-import _Object$assign from "@babel/runtime-corejs3/core-js-stable/object/assign";
-import _JSON$stringify from "@babel/runtime-corejs3/core-js-stable/json/stringify";
-import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
-import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
-import _findInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/find";
-
 /*
  * ISC License (ISC)
  * Copyright (c) 2018 aeternity developers
@@ -28,55 +19,33 @@ import { options, changeStatus, changeState, call, send, emit, channelId, discon
 import { unpackTx, buildTx } from '../tx/builder';
 
 function encodeRlpTx(rlpBinary) {
-  return "tx_".concat(encodeBase64Check(rlpBinary));
+  return `tx_${encodeBase64Check(rlpBinary)}`;
 }
 
-function appendSignature(_x, _x2) {
-  return _appendSignature.apply(this, arguments);
-}
+async function appendSignature(tx, signFn) {
+  const {
+    signatures,
+    encodedTx
+  } = unpackTx(tx).tx;
+  const result = await signFn(encodeRlpTx(encodedTx.rlpEncoded));
+
+  if (typeof result === 'string') {
+    const {
+      tx: signedTx,
+      txType
+    } = unpackTx(result);
+    return encodeRlpTx(buildTx({
+      signatures: signatures.concat(signedTx.signatures),
+      encodedTx: signedTx.encodedTx.rlpEncoded
+    }, txType).rlpEncoded);
+  }
 
-function _appendSignature() {
-  _appendSignature = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(tx, signFn) {
-    var _unpackTx$tx, signatures, encodedTx, result, _unpackTx, signedTx, txType;
-
-    return _regeneratorRuntime.wrap(function _callee$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            _unpackTx$tx = unpackTx(tx).tx, signatures = _unpackTx$tx.signatures, encodedTx = _unpackTx$tx.encodedTx;
-            _context4.next = 3;
-            return signFn(encodeRlpTx(encodedTx.rlpEncoded));
-
-          case 3:
-            result = _context4.sent;
-
-            if (!(typeof result === 'string')) {
-              _context4.next = 7;
-              break;
-            }
-
-            _unpackTx = unpackTx(result), signedTx = _unpackTx.tx, txType = _unpackTx.txType;
-            return _context4.abrupt("return", encodeRlpTx(buildTx({
-              signatures: _concatInstanceProperty(signatures).call(signatures, signedTx.signatures),
-              encodedTx: signedTx.encodedTx.rlpEncoded
-            }, txType).rlpEncoded));
-
-          case 7:
-            return _context4.abrupt("return", result);
-
-          case 8:
-          case "end":
-            return _context4.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _appendSignature.apply(this, arguments);
+  return result;
 }
 
 function handleUnexpectedMessage(channel, message, state) {
   if (state && state.reject) {
-    state.reject(_Object$assign(new Error("Unexpected message received:\n\n".concat(_JSON$stringify(message))), {
+    state.reject(Object.assign(new Error(`Unexpected message received:\n\n${JSON.stringify(message)}`), {
       wsMessage: message
     }));
   }
@@ -88,9 +57,7 @@ function handleUnexpectedMessage(channel, message, state) {
 
 export function awaitingConnection(channel, message, state) {
   if (message.method === 'channels.info') {
-    var _context;
-
-    if (_includesInstanceProperty(_context = ['channel_accept', 'funding_created']).call(_context, message.params.data.event)) {
+    if (['channel_accept', 'funding_created'].includes(message.params.data.event)) {
       changeStatus(channel, {
         channel_accept: 'accepted',
         funding_created: 'halfSigned'
@@ -125,124 +92,53 @@ export function awaitingConnection(channel, message, state) {
     };
   }
 }
-export function awaitingReconnection(_x3, _x4, _x5) {
-  return _awaitingReconnection.apply(this, arguments);
-}
-
-function _awaitingReconnection() {
-  _awaitingReconnection = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(channel, message, state) {
-    return _regeneratorRuntime.wrap(function _callee2$(_context5) {
-      while (1) {
-        switch (_context5.prev = _context5.next) {
-          case 0:
-            if (!(message.method === 'channels.info')) {
-              _context5.next = 10;
-              break;
-            }
-
-            if (!(message.params.data.event === 'fsm_up')) {
-              _context5.next = 10;
-              break;
-            }
-
-            fsmId.set(channel, message.params.data.fsm_id);
-            _context5.t0 = changeState;
-            _context5.t1 = channel;
-            _context5.next = 7;
-            return call(channel, 'channels.get.offchain_state', {});
-
-          case 7:
-            _context5.t2 = _context5.sent.signed_tx;
-            (0, _context5.t0)(_context5.t1, _context5.t2);
-            return _context5.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 10:
-            return _context5.abrupt("return", handleUnexpectedMessage(channel, message, state));
-
-          case 11:
-          case "end":
-            return _context5.stop();
-        }
-      }
-    }, _callee2);
-  }));
-  return _awaitingReconnection.apply(this, arguments);
-}
+export async function awaitingReconnection(channel, message, state) {
+  if (message.method === 'channels.info') {
+    if (message.params.data.event === 'fsm_up') {
+      fsmId.set(channel, message.params.data.fsm_id);
+      changeState(channel, (await call(channel, 'channels.get.offchain_state', {})).signed_tx);
+      return {
+        handler: channelOpen
+      };
+    }
+  }
 
-export function awaitingChannelCreateTx(_x6, _x7, _x8) {
-  return _awaitingChannelCreateTx.apply(this, arguments);
+  return handleUnexpectedMessage(channel, message, state);
 }
-
-function _awaitingChannelCreateTx() {
-  _awaitingChannelCreateTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(channel, message, state) {
-    var tag, _signedTx, signedTx;
-
-    return _regeneratorRuntime.wrap(function _callee3$(_context6) {
-      while (1) {
-        switch (_context6.prev = _context6.next) {
-          case 0:
-            tag = {
-              initiator: 'initiator_sign',
-              responder: 'responder_sign'
-            }[options.get(channel).role];
-
-            if (!(message.method === "channels.sign.".concat(tag))) {
-              _context6.next = 13;
-              break;
-            }
-
-            if (!message.params.data.tx) {
-              _context6.next = 8;
-              break;
-            }
-
-            _context6.next = 5;
-            return options.get(channel).sign(tag, message.params.data.tx);
-
-          case 5:
-            _signedTx = _context6.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: "channels.".concat(tag),
-              params: {
-                tx: _signedTx
-              }
-            });
-            return _context6.abrupt("return", {
-              handler: awaitingOnChainTx
-            });
-
-          case 8:
-            _context6.next = 10;
-            return appendSignature(message.params.data.signed_tx, function (tx) {
-              return options.get(channel).sign(tag, tx);
-            });
-
-          case 10:
-            signedTx = _context6.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: "channels.".concat(tag),
-              params: {
-                signed_tx: signedTx
-              }
-            });
-            return _context6.abrupt("return", {
-              handler: awaitingOnChainTx
-            });
-
-          case 13:
-          case "end":
-            return _context6.stop();
+export async function awaitingChannelCreateTx(channel, message, state) {
+  const tag = {
+    initiator: 'initiator_sign',
+    responder: 'responder_sign'
+  }[options.get(channel).role];
+
+  if (message.method === `channels.sign.${tag}`) {
+    if (message.params.data.tx) {
+      const signedTx = await options.get(channel).sign(tag, message.params.data.tx);
+      send(channel, {
+        jsonrpc: '2.0',
+        method: `channels.${tag}`,
+        params: {
+          tx: signedTx
         }
+      });
+      return {
+        handler: awaitingOnChainTx
+      };
+    }
+
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => options.get(channel).sign(tag, tx));
+    send(channel, {
+      jsonrpc: '2.0',
+      method: `channels.${tag}`,
+      params: {
+        signed_tx: signedTx
       }
-    }, _callee3);
-  }));
-  return _awaitingChannelCreateTx.apply(this, arguments);
+    });
+    return {
+      handler: awaitingOnChainTx
+    };
+  }
 }
-
 export function awaitingOnChainTx(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
     if (message.params.data.info === 'funding_signed' && options.get(channel).role === 'initiator') {
@@ -268,7 +164,7 @@ export function awaitingOnChainTx(channel, message, state) {
 }
 export function awaitingBlockInclusion(channel, message, state) {
   if (message.method === 'channels.info') {
-    var handler = {
+    const handler = {
       funding_created: awaitingBlockInclusion,
       own_funding_locked: awaitingBlockInclusion,
       funding_locked: awaitingOpenConfirmation
@@ -276,7 +172,7 @@ export function awaitingBlockInclusion(channel, message, state) {
 
     if (handler) {
       return {
-        handler: handler
+        handler
       };
     }
   }
@@ -307,284 +203,206 @@ export function awaitingInitialState(channel, message, state) {
     };
   }
 }
-export function channelOpen(_x9, _x10, _x11) {
-  return _channelOpen.apply(this, arguments);
-}
-
-function _channelOpen() {
-  _channelOpen = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(channel, message, state) {
-    return _regeneratorRuntime.wrap(function _callee4$(_context7) {
-      while (1) {
-        switch (_context7.prev = _context7.next) {
-          case 0:
-            _context7.t0 = message.method;
-            _context7.next = _context7.t0 === 'channels.info' ? 3 : _context7.t0 === 'channels.on_chain_tx' ? 20 : _context7.t0 === 'channels.leave' ? 22 : _context7.t0 === 'channels.update' ? 23 : _context7.t0 === 'channels.sign.shutdown_sign_ack' ? 25 : 26;
-            break;
-
-          case 3:
-            _context7.t1 = message.params.data.event;
-            _context7.next = _context7.t1 === 'update' ? 6 : _context7.t1 === 'withdraw_created' ? 6 : _context7.t1 === 'deposit_created' ? 6 : _context7.t1 === 'own_withdraw_locked' ? 7 : _context7.t1 === 'withdraw_locked' ? 7 : _context7.t1 === 'own_deposit_locked' ? 7 : _context7.t1 === 'deposit_locked' ? 7 : _context7.t1 === 'peer_disconnected' ? 7 : _context7.t1 === 'channel_reestablished' ? 7 : _context7.t1 === 'open' ? 7 : _context7.t1 === 'fsm_up' ? 9 : _context7.t1 === 'timeout' ? 11 : _context7.t1 === 'close_mutual' ? 11 : _context7.t1 === 'closing' ? 12 : _context7.t1 === 'closed_confirmed' ? 14 : _context7.t1 === 'died' ? 16 : _context7.t1 === 'shutdown' ? 18 : 19;
-            break;
-
-          case 6:
-            return _context7.abrupt("return", {
-              handler: awaitingTxSignRequest
-            });
-
-          case 7:
-            // TODO: Better handling of peer_disconnected event.
-            //
-            //       We should enter intermediate state where offchain transactions
-            //       are blocked until channel is reestablished.
-            emit(channel, message.params.data.event);
-            return _context7.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 9:
-            fsmId.set(channel, message.params.data.fsm_id);
-            return _context7.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 11:
-            return _context7.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 12:
-            changeStatus(channel, 'closing');
-            return _context7.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 14:
-            changeStatus(channel, 'closed');
-            return _context7.abrupt("return", {
-              handler: channelClosed
-            });
-
-          case 16:
-            changeStatus(channel, 'died');
-            return _context7.abrupt("return", {
-              handler: channelClosed
-            });
-
-          case 18:
-            return _context7.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 19:
-            return _context7.abrupt("break", 26);
-
-          case 20:
-            emit(channel, 'onChainTx', message.params.data.tx, {
-              info: message.params.data.info,
-              type: message.params.data.type
-            });
-            return _context7.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 22:
-            return _context7.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 23:
-            changeState(channel, message.params.data.state);
-            return _context7.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 25:
-            return _context7.abrupt("return", awaitingTxSignRequest(channel, message, state));
-
-          case 26:
-          case "end":
-            return _context7.stop();
-        }
+export async function channelOpen(channel, message, state) {
+  switch (message.method) {
+    case 'channels.info':
+      switch (message.params.data.event) {
+        case 'update':
+        case 'withdraw_created':
+        case 'deposit_created':
+          return {
+            handler: awaitingTxSignRequest
+          };
+
+        case 'own_withdraw_locked':
+        case 'withdraw_locked':
+        case 'own_deposit_locked':
+        case 'deposit_locked':
+        case 'peer_disconnected':
+        case 'channel_reestablished':
+        case 'open':
+          // TODO: Better handling of peer_disconnected event.
+          //
+          //       We should enter intermediate state where offchain transactions
+          //       are blocked until channel is reestablished.
+          emit(channel, message.params.data.event);
+          return {
+            handler: channelOpen
+          };
+
+        case 'fsm_up':
+          fsmId.set(channel, message.params.data.fsm_id);
+          return {
+            handler: channelOpen
+          };
+
+        case 'timeout':
+        case 'close_mutual':
+          return {
+            handler: channelOpen
+          };
+
+        case 'closing':
+          changeStatus(channel, 'closing');
+          return {
+            handler: channelOpen
+          };
+
+        case 'closed_confirmed':
+          changeStatus(channel, 'closed');
+          return {
+            handler: channelClosed
+          };
+
+        case 'died':
+          changeStatus(channel, 'died');
+          return {
+            handler: channelClosed
+          };
+
+        case 'shutdown':
+          return {
+            handler: channelOpen
+          };
       }
-    }, _callee4);
-  }));
-  return _channelOpen.apply(this, arguments);
+
+      break;
+
+    case 'channels.on_chain_tx':
+      emit(channel, 'onChainTx', message.params.data.tx, {
+        info: message.params.data.info,
+        type: message.params.data.type
+      });
+      return {
+        handler: channelOpen
+      };
+
+    case 'channels.leave':
+      // TODO: emit event
+      return {
+        handler: channelOpen
+      };
+
+    case 'channels.update':
+      changeState(channel, message.params.data.state);
+      return {
+        handler: channelOpen
+      };
+
+    case 'channels.sign.shutdown_sign_ack':
+      return awaitingTxSignRequest(channel, message, state);
+  }
 }
 
-channelOpen.enter = function (channel) {
+channelOpen.enter = channel => {
   changeStatus(channel, 'open');
 };
 
-export function awaitingOffChainTx(_x12, _x13, _x14) {
-  return _awaitingOffChainTx.apply(this, arguments);
-}
+export async function awaitingOffChainTx(channel, message, state) {
+  if (message.method === 'channels.sign.update') {
+    const {
+      sign
+    } = state;
 
-function _awaitingOffChainTx() {
-  _awaitingOffChainTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(channel, message, state) {
-    var sign, _signedTx2, signedTx, _message$error$data, data;
-
-    return _regeneratorRuntime.wrap(function _callee5$(_context8) {
-      while (1) {
-        switch (_context8.prev = _context8.next) {
-          case 0:
-            if (!(message.method === 'channels.sign.update')) {
-              _context8.next = 17;
-              break;
-            }
-
-            sign = state.sign;
-
-            if (!message.params.data.tx) {
-              _context8.next = 8;
-              break;
-            }
-
-            _context8.next = 5;
-            return sign(message.params.data.tx, {
-              updates: message.params.data.updates
-            });
-
-          case 5:
-            _signedTx2 = _context8.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update',
-              params: {
-                tx: _signedTx2
-              }
-            });
-            return _context8.abrupt("return", {
-              handler: awaitingOffChainUpdate,
-              state: state
-            });
-
-          case 8:
-            _context8.next = 10;
-            return appendSignature(message.params.data.signed_tx, function (tx) {
-              return sign(tx, {
-                updates: message.params.data.updates
-              });
-            });
-
-          case 10:
-            signedTx = _context8.sent;
-
-            if (!(typeof signedTx === 'string')) {
-              _context8.next = 14;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update',
-              params: {
-                signed_tx: signedTx
-              }
-            });
-            return _context8.abrupt("return", {
-              handler: awaitingOffChainUpdate,
-              state: state
-            });
-
-          case 14:
-            if (!(typeof signedTx === 'number')) {
-              _context8.next = 17;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update',
-              params: {
-                error: signedTx
-              }
-            });
-            return _context8.abrupt("return", {
-              handler: awaitingOffChainTx,
-              state: state
-            });
-
-          case 17:
-            if (!(message.method === 'channels.error')) {
-              _context8.next = 20;
-              break;
-            }
-
-            state.reject(new Error(message.data.message));
-            return _context8.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 20:
-            if (!message.error) {
-              _context8.next = 24;
-              break;
-            }
-
-            _message$error$data = message.error.data, data = _message$error$data === void 0 ? [] : _message$error$data;
-
-            if (_findInstanceProperty(data).call(data, function (i) {
-              return i.code === 1001;
-            })) {
-              state.reject(new Error('Insufficient balance'));
-            } else if (_findInstanceProperty(data).call(data, function (i) {
-              return i.code === 1002;
-            })) {
-              state.reject(new Error('Amount cannot be negative'));
-            } else {
-              state.reject(new Error(message.error.message));
-            }
-
-            return _context8.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 24:
-            if (!(message.method === 'channels.conflict')) {
-              _context8.next = 27;
-              break;
-            }
-
-            state.resolve({
-              accepted: false,
-              errorCode: message.params.data.error_code,
-              errorMessage: message.params.data.error_msg
-            });
-            return _context8.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 27:
-            if (!(message.method === 'channels.info')) {
-              _context8.next = 31;
-              break;
-            }
-
-            if (!(message.params.data.event === 'aborted_update')) {
-              _context8.next = 31;
-              break;
-            }
-
-            state.resolve({
-              accepted: false
-            });
-            return _context8.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 31:
-            return _context8.abrupt("return", handleUnexpectedMessage(channel, message, state));
-
-          case 32:
-          case "end":
-            return _context8.stop();
+    if (message.params.data.tx) {
+      const signedTx = await sign(message.params.data.tx, {
+        updates: message.params.data.updates
+      });
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.update',
+        params: {
+          tx: signedTx
         }
-      }
-    }, _callee5);
-  }));
-  return _awaitingOffChainTx.apply(this, arguments);
-}
+      });
+      return {
+        handler: awaitingOffChainUpdate,
+        state
+      };
+    }
+
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => sign(tx, {
+      updates: message.params.data.updates
+    }));
 
+    if (typeof signedTx === 'string') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.update',
+        params: {
+          signed_tx: signedTx
+        }
+      });
+      return {
+        handler: awaitingOffChainUpdate,
+        state
+      };
+    }
+
+    if (typeof signedTx === 'number') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.update',
+        params: {
+          error: signedTx
+        }
+      });
+      return {
+        handler: awaitingOffChainTx,
+        state
+      };
+    }
+  }
+
+  if (message.method === 'channels.error') {
+    state.reject(new Error(message.data.message));
+    return {
+      handler: channelOpen
+    };
+  }
+
+  if (message.error) {
+    const {
+      data = []
+    } = message.error;
+
+    if (data.find(i => i.code === 1001)) {
+      state.reject(new Error('Insufficient balance'));
+    } else if (data.find(i => i.code === 1002)) {
+      state.reject(new Error('Amount cannot be negative'));
+    } else {
+      state.reject(new Error(message.error.message));
+    }
+
+    return {
+      handler: channelOpen
+    };
+  }
+
+  if (message.method === 'channels.conflict') {
+    state.resolve({
+      accepted: false,
+      errorCode: message.params.data.error_code,
+      errorMessage: message.params.data.error_msg
+    });
+    return {
+      handler: channelOpen
+    };
+  }
+
+  if (message.method === 'channels.info') {
+    if (message.params.data.event === 'aborted_update') {
+      state.resolve({
+        accepted: false
+      });
+      return {
+        handler: channelOpen
+      };
+    }
+  }
+
+  return handleUnexpectedMessage(channel, message, state);
+}
 export function awaitingOffChainUpdate(channel, message, state) {
   if (message.method === 'channels.update') {
     changeState(channel, message.params.data.state);
@@ -628,137 +446,83 @@ export function awaitingOffChainUpdate(channel, message, state) {
 
   return handleUnexpectedMessage(channel, message, state);
 }
-export function awaitingTxSignRequest(_x15, _x16, _x17) {
-  return _awaitingTxSignRequest.apply(this, arguments);
-}
+export async function awaitingTxSignRequest(channel, message, state) {
+  const [, tag] = message.method.match(/^channels\.sign\.([^.]+)$/) || [];
 
-function _awaitingTxSignRequest() {
-  _awaitingTxSignRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(channel, message, state) {
-    var _ref, _ref2, tag, signedTx, _signedTx3;
-
-    return _regeneratorRuntime.wrap(function _callee6$(_context9) {
-      while (1) {
-        switch (_context9.prev = _context9.next) {
-          case 0:
-            _ref = message.method.match(/^channels\.sign\.([^.]+)$/) || [], _ref2 = _slicedToArray(_ref, 2), tag = _ref2[1];
-
-            if (!tag) {
-              _context9.next = 22;
-              break;
-            }
-
-            if (!message.params.data.tx) {
-              _context9.next = 11;
-              break;
-            }
-
-            _context9.next = 5;
-            return options.get(channel).sign(tag, message.params.data.tx, {
-              updates: message.params.data.updates
-            });
-
-          case 5:
-            signedTx = _context9.sent;
-
-            if (!signedTx) {
-              _context9.next = 9;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: "channels.".concat(tag),
-              params: {
-                tx: signedTx
-              }
-            });
-            return _context9.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 9:
-            _context9.next = 20;
-            break;
-
-          case 11:
-            _context9.next = 13;
-            return appendSignature(message.params.data.signed_tx, function (tx) {
-              return options.get(channel).sign(tag, tx, {
-                updates: message.params.data.updates
-              });
-            });
-
-          case 13:
-            _signedTx3 = _context9.sent;
-
-            if (!(typeof _signedTx3 === 'string')) {
-              _context9.next = 17;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: "channels.".concat(tag),
-              params: {
-                signed_tx: _signedTx3
-              }
-            });
-            return _context9.abrupt("return", {
-              handler: channelOpen
-            });
-
-          case 17:
-            if (!(typeof _signedTx3 === 'number')) {
-              _context9.next = 20;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: "channels.".concat(tag),
-              params: {
-                error: _signedTx3
-              }
-            });
-            return _context9.abrupt("return", {
-              handler: awaitingUpdateConflict,
-              state: state
-            });
-
-          case 20:
-            // soft-reject via competing update
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update.new',
-              params: {
-                from: generateKeyPair().publicKey,
-                to: generateKeyPair().publicKey,
-                amount: 1
-              }
-            });
-            return _context9.abrupt("return", {
-              handler: awaitingUpdateConflict,
-              state: state
-            });
-
-          case 22:
-            return _context9.abrupt("return", handleUnexpectedMessage(channel, message, state));
-
-          case 23:
-          case "end":
-            return _context9.stop();
-        }
+  if (tag) {
+    if (message.params.data.tx) {
+      const signedTx = await options.get(channel).sign(tag, message.params.data.tx, {
+        updates: message.params.data.updates
+      });
+
+      if (signedTx) {
+        send(channel, {
+          jsonrpc: '2.0',
+          method: `channels.${tag}`,
+          params: {
+            tx: signedTx
+          }
+        });
+        return {
+          handler: channelOpen
+        };
       }
-    }, _callee6);
-  }));
-  return _awaitingTxSignRequest.apply(this, arguments);
-}
+    } else {
+      const signedTx = await appendSignature(message.params.data.signed_tx, tx => options.get(channel).sign(tag, tx, {
+        updates: message.params.data.updates
+      }));
+
+      if (typeof signedTx === 'string') {
+        send(channel, {
+          jsonrpc: '2.0',
+          method: `channels.${tag}`,
+          params: {
+            signed_tx: signedTx
+          }
+        });
+        return {
+          handler: channelOpen
+        };
+      }
+
+      if (typeof signedTx === 'number') {
+        send(channel, {
+          jsonrpc: '2.0',
+          method: `channels.${tag}`,
+          params: {
+            error: signedTx
+          }
+        });
+        return {
+          handler: awaitingUpdateConflict,
+          state
+        };
+      }
+    } // soft-reject via competing update
+
+
+    send(channel, {
+      jsonrpc: '2.0',
+      method: 'channels.update.new',
+      params: {
+        from: generateKeyPair().publicKey,
+        to: generateKeyPair().publicKey,
+        amount: 1
+      }
+    });
+    return {
+      handler: awaitingUpdateConflict,
+      state
+    };
+  }
 
+  return handleUnexpectedMessage(channel, message, state);
+}
 export function awaitingUpdateConflict(channel, message, state) {
   if (message.error) {
     return {
       handler: awaitingUpdateConflict,
-      state: state
+      state
     };
   }
 
@@ -770,84 +534,45 @@ export function awaitingUpdateConflict(channel, message, state) {
 
   return handleUnexpectedMessage(channel, message, state);
 }
-export function awaitingShutdownTx(_x18, _x19, _x20) {
-  return _awaitingShutdownTx.apply(this, arguments);
-}
-
-function _awaitingShutdownTx() {
-  _awaitingShutdownTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(channel, message, state) {
-    var _signedTx4, signedTx;
-
-    return _regeneratorRuntime.wrap(function _callee7$(_context10) {
-      while (1) {
-        switch (_context10.prev = _context10.next) {
-          case 0:
-            if (!(message.method === 'channels.sign.shutdown_sign')) {
-              _context10.next = 12;
-              break;
-            }
-
-            if (!message.params.data.tx) {
-              _context10.next = 7;
-              break;
-            }
-
-            _context10.next = 4;
-            return state.sign(message.params.data.tx);
-
-          case 4:
-            _signedTx4 = _context10.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.shutdown_sign',
-              params: {
-                tx: _signedTx4
-              }
-            });
-            return _context10.abrupt("return", {
-              handler: awaitingShutdownOnChainTx,
-              state: state
-            });
-
-          case 7:
-            _context10.next = 9;
-            return appendSignature(message.params.data.signed_tx, function (tx) {
-              return state.sign(tx);
-            });
-
-          case 9:
-            signedTx = _context10.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.shutdown_sign',
-              params: {
-                signed_tx: signedTx
-              }
-            });
-            return _context10.abrupt("return", {
-              handler: awaitingShutdownOnChainTx,
-              state: state
-            });
-
-          case 12:
-            return _context10.abrupt("return", handleUnexpectedMessage(channel, message, state));
-
-          case 13:
-          case "end":
-            return _context10.stop();
+export async function awaitingShutdownTx(channel, message, state) {
+  if (message.method === 'channels.sign.shutdown_sign') {
+    if (message.params.data.tx) {
+      const signedTx = await state.sign(message.params.data.tx);
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.shutdown_sign',
+        params: {
+          tx: signedTx
         }
+      });
+      return {
+        handler: awaitingShutdownOnChainTx,
+        state
+      };
+    }
+
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => state.sign(tx));
+    send(channel, {
+      jsonrpc: '2.0',
+      method: 'channels.shutdown_sign',
+      params: {
+        signed_tx: signedTx
       }
-    }, _callee7);
-  }));
-  return _awaitingShutdownTx.apply(this, arguments);
-}
+    });
+    return {
+      handler: awaitingShutdownOnChainTx,
+      state
+    };
+  }
 
+  return handleUnexpectedMessage(channel, message, state);
+}
 export function awaitingShutdownOnChainTx(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
     // state.resolve(message.params.data.tx)
     return {
       handler: channelClosed,
-      state: state
+      state
     };
   }
 
@@ -874,108 +599,64 @@ export function awaitingLeave(channel, message, state) {
 
   return handleUnexpectedMessage(channel, message, state);
 }
-export function awaitingWithdrawTx(_x21, _x22, _x23) {
-  return _awaitingWithdrawTx.apply(this, arguments);
-}
+export async function awaitingWithdrawTx(channel, message, state) {
+  if (message.method === 'channels.sign.withdraw_tx') {
+    const {
+      sign
+    } = state;
+
+    if (message.params.data.tx) {
+      const signedTx = await sign(message.params.data.tx, {
+        updates: message.params.data.updates
+      });
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.withdraw_tx',
+        params: {
+          tx: signedTx
+        }
+      });
+      return {
+        handler: awaitingWithdrawCompletion,
+        state
+      };
+    }
 
-function _awaitingWithdrawTx() {
-  _awaitingWithdrawTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(channel, message, state) {
-    var sign, _signedTx5, signedTx;
-
-    return _regeneratorRuntime.wrap(function _callee8$(_context11) {
-      while (1) {
-        switch (_context11.prev = _context11.next) {
-          case 0:
-            if (!(message.method === 'channels.sign.withdraw_tx')) {
-              _context11.next = 17;
-              break;
-            }
-
-            sign = state.sign;
-
-            if (!message.params.data.tx) {
-              _context11.next = 8;
-              break;
-            }
-
-            _context11.next = 5;
-            return sign(message.params.data.tx, {
-              updates: message.params.data.updates
-            });
-
-          case 5:
-            _signedTx5 = _context11.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.withdraw_tx',
-              params: {
-                tx: _signedTx5
-              }
-            });
-            return _context11.abrupt("return", {
-              handler: awaitingWithdrawCompletion,
-              state: state
-            });
-
-          case 8:
-            _context11.next = 10;
-            return appendSignature(message.params.data.signed_tx, function (tx) {
-              return sign(tx, {
-                updates: message.params.data.updates
-              });
-            });
-
-          case 10:
-            signedTx = _context11.sent;
-
-            if (!(typeof signedTx === 'string')) {
-              _context11.next = 14;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.withdraw_tx',
-              params: {
-                signed_tx: signedTx
-              }
-            });
-            return _context11.abrupt("return", {
-              handler: awaitingWithdrawCompletion,
-              state: state
-            });
-
-          case 14:
-            if (!(typeof signedTx === 'number')) {
-              _context11.next = 17;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.withdraw_tx',
-              params: {
-                error: signedTx
-              }
-            });
-            return _context11.abrupt("return", {
-              handler: awaitingWithdrawCompletion,
-              state: state
-            });
-
-          case 17:
-            return _context11.abrupt("return", handleUnexpectedMessage(channel, message, state));
-
-          case 18:
-          case "end":
-            return _context11.stop();
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => sign(tx, {
+      updates: message.params.data.updates
+    }));
+
+    if (typeof signedTx === 'string') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.withdraw_tx',
+        params: {
+          signed_tx: signedTx
         }
-      }
-    }, _callee8);
-  }));
-  return _awaitingWithdrawTx.apply(this, arguments);
-}
+      });
+      return {
+        handler: awaitingWithdrawCompletion,
+        state
+      };
+    }
+
+    if (typeof signedTx === 'number') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.withdraw_tx',
+        params: {
+          error: signedTx
+        }
+      });
+      return {
+        handler: awaitingWithdrawCompletion,
+        state
+      };
+    }
+  }
 
+  return handleUnexpectedMessage(channel, message, state);
+}
 export function awaitingWithdrawCompletion(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
     if (state.onOnChainTx) {
@@ -984,15 +665,13 @@ export function awaitingWithdrawCompletion(channel, message, state) {
 
     return {
       handler: awaitingWithdrawCompletion,
-      state: state
+      state
     };
   }
 
   if (message.method === 'channels.info') {
-    var _context2;
-
-    if (_includesInstanceProperty(_context2 = ['own_withdraw_locked', 'withdraw_locked']).call(_context2, message.params.data.event)) {
-      var callback = {
+    if (['own_withdraw_locked', 'withdraw_locked'].includes(message.params.data.event)) {
+      const callback = {
         own_withdraw_locked: state.onOwnWithdrawLocked,
         withdraw_locked: state.onWithdrawLocked
       }[message.params.data.event];
@@ -1003,7 +682,7 @@ export function awaitingWithdrawCompletion(channel, message, state) {
 
       return {
         handler: awaitingWithdrawCompletion,
-        state: state
+        state
       };
     }
   }
@@ -1043,108 +722,64 @@ export function awaitingWithdrawCompletion(channel, message, state) {
 
   return handleUnexpectedMessage(channel, message, state);
 }
-export function awaitingDepositTx(_x24, _x25, _x26) {
-  return _awaitingDepositTx.apply(this, arguments);
-}
+export async function awaitingDepositTx(channel, message, state) {
+  if (message.method === 'channels.sign.deposit_tx') {
+    const {
+      sign
+    } = state;
+
+    if (message.params.data.tx) {
+      const signedTx = await sign(message.params.data.tx, {
+        updates: message.params.data.updates
+      });
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.deposit_tx',
+        params: {
+          tx: signedTx
+        }
+      });
+      return {
+        handler: awaitingDepositCompletion,
+        state
+      };
+    }
 
-function _awaitingDepositTx() {
-  _awaitingDepositTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(channel, message, state) {
-    var sign, _signedTx6, signedTx;
-
-    return _regeneratorRuntime.wrap(function _callee9$(_context12) {
-      while (1) {
-        switch (_context12.prev = _context12.next) {
-          case 0:
-            if (!(message.method === 'channels.sign.deposit_tx')) {
-              _context12.next = 17;
-              break;
-            }
-
-            sign = state.sign;
-
-            if (!message.params.data.tx) {
-              _context12.next = 8;
-              break;
-            }
-
-            _context12.next = 5;
-            return sign(message.params.data.tx, {
-              updates: message.params.data.updates
-            });
-
-          case 5:
-            _signedTx6 = _context12.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.deposit_tx',
-              params: {
-                tx: _signedTx6
-              }
-            });
-            return _context12.abrupt("return", {
-              handler: awaitingDepositCompletion,
-              state: state
-            });
-
-          case 8:
-            _context12.next = 10;
-            return appendSignature(message.params.data.signed_tx, function (tx) {
-              return sign(tx, {
-                updates: message.params.data.updates
-              });
-            });
-
-          case 10:
-            signedTx = _context12.sent;
-
-            if (!(typeof signedTx === 'string')) {
-              _context12.next = 14;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.deposit_tx',
-              params: {
-                signed_tx: signedTx
-              }
-            });
-            return _context12.abrupt("return", {
-              handler: awaitingDepositCompletion,
-              state: state
-            });
-
-          case 14:
-            if (!(typeof signedTx === 'number')) {
-              _context12.next = 17;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.deposit_tx',
-              params: {
-                error: signedTx
-              }
-            });
-            return _context12.abrupt("return", {
-              handler: awaitingDepositCompletion,
-              state: state
-            });
-
-          case 17:
-            return _context12.abrupt("return", handleUnexpectedMessage(channel, message, state));
-
-          case 18:
-          case "end":
-            return _context12.stop();
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => sign(tx, {
+      updates: message.params.data.updates
+    }));
+
+    if (typeof signedTx === 'string') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.deposit_tx',
+        params: {
+          signed_tx: signedTx
         }
-      }
-    }, _callee9);
-  }));
-  return _awaitingDepositTx.apply(this, arguments);
-}
+      });
+      return {
+        handler: awaitingDepositCompletion,
+        state
+      };
+    }
+
+    if (typeof signedTx === 'number') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.deposit_tx',
+        params: {
+          error: signedTx
+        }
+      });
+      return {
+        handler: awaitingDepositCompletion,
+        state
+      };
+    }
+  }
 
+  return handleUnexpectedMessage(channel, message, state);
+}
 export function awaitingDepositCompletion(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
     if (state.onOnChainTx) {
@@ -1153,15 +788,13 @@ export function awaitingDepositCompletion(channel, message, state) {
 
     return {
       handler: awaitingDepositCompletion,
-      state: state
+      state
     };
   }
 
   if (message.method === 'channels.info') {
-    var _context3;
-
-    if (_includesInstanceProperty(_context3 = ['own_deposit_locked', 'deposit_locked']).call(_context3, message.params.data.event)) {
-      var callback = {
+    if (['own_deposit_locked', 'deposit_locked'].includes(message.params.data.event)) {
+      const callback = {
         own_deposit_locked: state.onOwnDepositLocked,
         deposit_locked: state.onDepositLocked
       }[message.params.data.event];
@@ -1172,7 +805,7 @@ export function awaitingDepositCompletion(channel, message, state) {
 
       return {
         handler: awaitingDepositCompletion,
-        state: state
+        state
       };
     }
   }
@@ -1212,106 +845,62 @@ export function awaitingDepositCompletion(channel, message, state) {
 
   return handleUnexpectedMessage(channel, message, state);
 }
-export function awaitingNewContractTx(_x27, _x28, _x29) {
-  return _awaitingNewContractTx.apply(this, arguments);
-}
+export async function awaitingNewContractTx(channel, message, state) {
+  if (message.method === 'channels.sign.update') {
+    if (message.params.data.tx) {
+      const signedTx = await state.sign(message.params.data.tx);
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.update',
+        params: {
+          tx: signedTx
+        }
+      });
+      return {
+        handler: awaitingNewContractCompletion,
+        state
+      };
+    }
 
-function _awaitingNewContractTx() {
-  _awaitingNewContractTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(channel, message, state) {
-    var _signedTx7, signedTx;
-
-    return _regeneratorRuntime.wrap(function _callee10$(_context13) {
-      while (1) {
-        switch (_context13.prev = _context13.next) {
-          case 0:
-            if (!(message.method === 'channels.sign.update')) {
-              _context13.next = 16;
-              break;
-            }
-
-            if (!message.params.data.tx) {
-              _context13.next = 7;
-              break;
-            }
-
-            _context13.next = 4;
-            return state.sign(message.params.data.tx);
-
-          case 4:
-            _signedTx7 = _context13.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update',
-              params: {
-                tx: _signedTx7
-              }
-            });
-            return _context13.abrupt("return", {
-              handler: awaitingNewContractCompletion,
-              state: state
-            });
-
-          case 7:
-            _context13.next = 9;
-            return appendSignature(message.params.data.signed_tx, function (tx) {
-              return state.sign(tx);
-            });
-
-          case 9:
-            signedTx = _context13.sent;
-
-            if (!(typeof signedTx === 'string')) {
-              _context13.next = 13;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update',
-              params: {
-                signed_tx: signedTx
-              }
-            });
-            return _context13.abrupt("return", {
-              handler: awaitingNewContractCompletion,
-              state: state
-            });
-
-          case 13:
-            if (!(typeof signedTx === 'number')) {
-              _context13.next = 16;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update',
-              params: {
-                error: signedTx
-              }
-            });
-            return _context13.abrupt("return", {
-              handler: awaitingNewContractCompletion,
-              state: state
-            });
-
-          case 16:
-            return _context13.abrupt("return", handleUnexpectedMessage(channel, message, state));
-
-          case 17:
-          case "end":
-            return _context13.stop();
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => state.sign(tx));
+
+    if (typeof signedTx === 'string') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.update',
+        params: {
+          signed_tx: signedTx
         }
-      }
-    }, _callee10);
-  }));
-  return _awaitingNewContractTx.apply(this, arguments);
-}
+      });
+      return {
+        handler: awaitingNewContractCompletion,
+        state
+      };
+    }
+
+    if (typeof signedTx === 'number') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.update',
+        params: {
+          error: signedTx
+        }
+      });
+      return {
+        handler: awaitingNewContractCompletion,
+        state
+      };
+    }
+  }
 
+  return handleUnexpectedMessage(channel, message, state);
+}
 export function awaitingNewContractCompletion(channel, message, state) {
   if (message.method === 'channels.update') {
-    var round = unpackTx(message.params.data.state).tx.encodedTx.tx.round;
-    var owner = options.get(channel)[{
+    const {
+      round
+    } = unpackTx(message.params.data.state).tx.encodedTx.tx;
+    const owner = options.get(channel)[{
       initiator: 'initiatorId',
       responder: 'responderId'
     }[options.get(channel).role]];
@@ -1350,159 +939,81 @@ export function awaitingNewContractCompletion(channel, message, state) {
 
   return handleUnexpectedMessage(channel, message, state);
 }
-export function awaitingCallContractUpdateTx(_x30, _x31, _x32) {
-  return _awaitingCallContractUpdateTx.apply(this, arguments);
-}
-
-function _awaitingCallContractUpdateTx() {
-  _awaitingCallContractUpdateTx = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11(channel, message, state) {
-    var _signedTx8, signedTx;
-
-    return _regeneratorRuntime.wrap(function _callee11$(_context14) {
-      while (1) {
-        switch (_context14.prev = _context14.next) {
-          case 0:
-            if (!(message.method === 'channels.sign.update')) {
-              _context14.next = 16;
-              break;
-            }
-
-            if (!message.params.data.tx) {
-              _context14.next = 7;
-              break;
-            }
-
-            _context14.next = 4;
-            return state.sign(message.params.data.tx, {
-              updates: message.params.data.updates
-            });
-
-          case 4:
-            _signedTx8 = _context14.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update',
-              params: {
-                tx: _signedTx8
-              }
-            });
-            return _context14.abrupt("return", {
-              handler: awaitingCallContractCompletion,
-              state: state
-            });
-
-          case 7:
-            _context14.next = 9;
-            return appendSignature(message.params.data.signed_tx, function (tx) {
-              return state.sign(tx, {
-                updates: message.params.data.updates
-              });
-            });
-
-          case 9:
-            signedTx = _context14.sent;
-
-            if (!(typeof signedTx === 'string')) {
-              _context14.next = 13;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update',
-              params: {
-                signed_tx: signedTx
-              }
-            });
-            return _context14.abrupt("return", {
-              handler: awaitingCallContractCompletion,
-              state: state
-            });
-
-          case 13:
-            if (!(typeof signedTx === 'number')) {
-              _context14.next = 16;
-              break;
-            }
-
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.update',
-              params: {
-                error: signedTx
-              }
-            });
-            return _context14.abrupt("return", {
-              handler: awaitingCallContractCompletion,
-              state: state
-            });
-
-          case 16:
-            return _context14.abrupt("return", handleUnexpectedMessage(channel, message, state));
-
-          case 17:
-          case "end":
-            return _context14.stop();
+export async function awaitingCallContractUpdateTx(channel, message, state) {
+  if (message.method === 'channels.sign.update') {
+    if (message.params.data.tx) {
+      const signedTx = await state.sign(message.params.data.tx, {
+        updates: message.params.data.updates
+      });
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.update',
+        params: {
+          tx: signedTx
         }
-      }
-    }, _callee11);
-  }));
-  return _awaitingCallContractUpdateTx.apply(this, arguments);
-}
+      });
+      return {
+        handler: awaitingCallContractCompletion,
+        state
+      };
+    }
 
-export function awaitingCallContractForceProgressUpdate(_x33, _x34, _x35) {
-  return _awaitingCallContractForceProgressUpdate.apply(this, arguments);
-}
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => state.sign(tx, {
+      updates: message.params.data.updates
+    }));
 
-function _awaitingCallContractForceProgressUpdate() {
-  _awaitingCallContractForceProgressUpdate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12(channel, message, state) {
-    var signedTx;
-    return _regeneratorRuntime.wrap(function _callee12$(_context15) {
-      while (1) {
-        switch (_context15.prev = _context15.next) {
-          case 0:
-            if (!(message.method === 'channels.sign.force_progress_tx')) {
-              _context15.next = 6;
-              break;
-            }
-
-            _context15.next = 3;
-            return appendSignature(message.params.data.signed_tx, function (tx) {
-              return state.sign(tx, {
-                updates: message.params.data.updates
-              });
-            });
-
-          case 3:
-            signedTx = _context15.sent;
-            send(channel, {
-              jsonrpc: '2.0',
-              method: 'channels.force_progress_sign',
-              params: {
-                signed_tx: signedTx
-              }
-            });
-            return _context15.abrupt("return", {
-              handler: awaitingForceProgressCompletion,
-              state: state
-            });
-
-          case 6:
-            return _context15.abrupt("return", handleUnexpectedMessage(channel, message, state));
-
-          case 7:
-          case "end":
-            return _context15.stop();
+    if (typeof signedTx === 'string') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.update',
+        params: {
+          signed_tx: signedTx
         }
-      }
-    }, _callee12);
-  }));
-  return _awaitingCallContractForceProgressUpdate.apply(this, arguments);
+      });
+      return {
+        handler: awaitingCallContractCompletion,
+        state
+      };
+    }
+
+    if (typeof signedTx === 'number') {
+      send(channel, {
+        jsonrpc: '2.0',
+        method: 'channels.update',
+        params: {
+          error: signedTx
+        }
+      });
+      return {
+        handler: awaitingCallContractCompletion,
+        state
+      };
+    }
+  }
+
+  return handleUnexpectedMessage(channel, message, state);
 }
+export async function awaitingCallContractForceProgressUpdate(channel, message, state) {
+  if (message.method === 'channels.sign.force_progress_tx') {
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => state.sign(tx, {
+      updates: message.params.data.updates
+    }));
+    send(channel, {
+      jsonrpc: '2.0',
+      method: 'channels.force_progress_sign',
+      params: {
+        signed_tx: signedTx
+      }
+    });
+    return {
+      handler: awaitingForceProgressCompletion,
+      state
+    };
+  }
 
+  return handleUnexpectedMessage(channel, message, state);
+}
 export function awaitingForceProgressCompletion(channel, message, state) {
-  console.log('From force progress await completion ->', message);
-
   if (message.method === 'channels.on_chain_tx') {
     if (state.onOnChainTx) {
       state.onOnChainTx(message.params.data);
@@ -1575,14 +1086,14 @@ export function channelClosed(channel, message, state) {
   };
   if (message.params.data.event === 'closing') return {
     handler: channelClosed,
-    state: state
+    state
   };
 
   if (message.params.data.info === 'channel_closed') {
     state.closeTx = message.params.data.tx;
     return {
       handler: channelClosed,
-      state: state
+      state
     };
   }
 
@@ -1595,7 +1106,7 @@ export function channelClosed(channel, message, state) {
 
   return {
     handler: channelClosed,
-    state: state
+    state
   };
 }
 //# sourceMappingURL=handlers.js.map