@aeternity/aepp-sdk/es/channel/handlers.js

SDK for the æternity blockchain

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
 *
 *  Permission to use, copy, modify, and/or distribute this software for any
 *  purpose with or without fee is hereby granted, provided that the above
 *  copyright notice and this permission notice appear in all copies.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 *  PERFORMANCE OF THIS SOFTWARE.
 */
import { generateKeyPair, encodeContractAddress, encodeBase64Check } from '../utils/crypto';
import { options, changeStatus, changeState, call, send, emit, channelId, disconnect, fsmId } from './internal';
import { unpackTx, buildTx } from '../tx/builder';

function encodeRlpTx(rlpBinary) {
  return "tx_".concat(encodeBase64Check(rlpBinary));
}

function appendSignature(_x, _x2) {
  return _appendSignature.apply(this, arguments);
}

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);
}

function handleUnexpectedMessage(channel, message, state) {
  if (state && state.reject) {
    state.reject(_Object$assign(new Error("Unexpected message received:\n\n".concat(_JSON$stringify(message))), {
      wsMessage: message
    }));
  }

  return {
    handler: channelOpen
  };
}

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)) {
      changeStatus(channel, {
        channel_accept: 'accepted',
        funding_created: 'halfSigned'
      }[message.params.data.event]);
      return {
        handler: awaitingChannelCreateTx
      };
    }

    if (message.params.data.event === 'channel_reestablished') {
      return {
        handler: awaitingOpenConfirmation
      };
    }

    if (message.params.data.event === 'fsm_up') {
      fsmId.set(channel, message.params.data.fsm_id);
      return {
        handler: awaitingConnection
      };
    }

    return {
      handler: awaitingConnection
    };
  }

  if (message.method === 'channels.error') {
    emit(channel, 'error', new Error(message.payload.message));
    return {
      handler: channelClosed
    };
  }
}
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 function awaitingChannelCreateTx(_x6, _x7, _x8) {
  return _awaitingChannelCreateTx.apply(this, arguments);
}

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();
        }
      }
    }, _callee3);
  }));
  return _awaitingChannelCreateTx.apply(this, arguments);
}

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') {
      return {
        handler: awaitingBlockInclusion
      };
    }

    if (message.params.data.info === 'funding_created' && options.get(channel).role === 'responder') {
      return {
        handler: awaitingBlockInclusion
      };
    }
  }

  if (message.method === 'channels.info' && message.params.data.event === 'funding_signed' && options.get(channel).role === 'initiator') {
    channelId.set(channel, message.params.channel_id);
    changeStatus(channel, 'signed');
    return {
      handler: awaitingOnChainTx
    };
  }
}
export function awaitingBlockInclusion(channel, message, state) {
  if (message.method === 'channels.info') {
    var handler = {
      funding_created: awaitingBlockInclusion,
      own_funding_locked: awaitingBlockInclusion,
      funding_locked: awaitingOpenConfirmation
    }[message.params.data.event];

    if (handler) {
      return {
        handler: handler
      };
    }
  }

  if (message.method === 'channels.on_chain_tx') {
    emit(channel, 'onChainTx', message.params.data.tx, {
      info: message.params.data.info,
      type: message.params.data.type
    });
    return {
      handler: awaitingBlockInclusion
    };
  }
}
export function awaitingOpenConfirmation(channel, message, state) {
  if (message.method === 'channels.info' && message.params.data.event === 'open') {
    channelId.set(channel, message.params.channel_id);
    return {
      handler: awaitingInitialState
    };
  }
}
export function awaitingInitialState(channel, message, state) {
  if (message.method === 'channels.update') {
    changeState(channel, message.params.data.state);
    return {
      handler: channelOpen
    };
  }
}
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();
        }
      }
    }, _callee4);
  }));
  return _channelOpen.apply(this, arguments);
}

channelOpen.enter = function (channel) {
  changeStatus(channel, 'open');
};

export function awaitingOffChainTx(_x12, _x13, _x14) {
  return _awaitingOffChainTx.apply(this, arguments);
}

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();
        }
      }
    }, _callee5);
  }));
  return _awaitingOffChainTx.apply(this, arguments);
}

export function awaitingOffChainUpdate(channel, message, state) {
  if (message.method === 'channels.update') {
    changeState(channel, message.params.data.state);
    state.resolve({
      accepted: true,
      signedTx: message.params.data.state
    });
    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
      };
    }
  }

  if (message.error) {
    state.reject(new Error(message.error.message));
    return {
      handler: channelOpen
    };
  }

  return handleUnexpectedMessage(channel, message, state);
}
export function awaitingTxSignRequest(_x15, _x16, _x17) {
  return _awaitingTxSignRequest.apply(this, arguments);
}

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();
        }
      }
    }, _callee6);
  }));
  return _awaitingTxSignRequest.apply(this, arguments);
}

export function awaitingUpdateConflict(channel, message, state) {
  if (message.error) {
    return {
      handler: awaitingUpdateConflict,
      state: state
    };
  }

  if (message.method === 'channels.conflict') {
    return {
      handler: channelOpen
    };
  }

  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();
        }
      }
    }, _callee7);
  }));
  return _awaitingShutdownTx.apply(this, arguments);
}

export function awaitingShutdownOnChainTx(channel, message, state) {
  if (message.method === 'channels.on_chain_tx') {
    // state.resolve(message.params.data.tx)
    return {
      handler: channelClosed,
      state: state
    };
  }

  return handleUnexpectedMessage(channel, message, state);
}
export function awaitingLeave(channel, message, state) {
  if (message.method === 'channels.leave') {
    state.resolve({
      channelId: message.params.channel_id,
      signedTx: message.params.data.state
    });
    disconnect(channel);
    return {
      handler: channelClosed
    };
  }

  if (message.method === 'channels.error') {
    state.reject(new Error(message.data.message));
    return {
      handler: channelOpen
    };
  }

  return handleUnexpectedMessage(channel, message, state);
}
export function awaitingWithdrawTx(_x21, _x22, _x23) {
  return _awaitingWithdrawTx.apply(this, arguments);
}

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();
        }
      }
    }, _callee8);
  }));
  return _awaitingWithdrawTx.apply(this, arguments);
}

export function awaitingWithdrawCompletion(channel, message, state) {
  if (message.method === 'channels.on_chain_tx') {
    if (state.onOnChainTx) {
      state.onOnChainTx(message.params.data.tx);
    }

    return {
      handler: awaitingWithdrawCompletion,
      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 = {
        own_withdraw_locked: state.onOwnWithdrawLocked,
        withdraw_locked: state.onWithdrawLocked
      }[message.params.data.event];

      if (callback) {
        callback();
      }

      return {
        handler: awaitingWithdrawCompletion,
        state: state
      };
    }
  }

  if (message.method === 'channels.update') {
    changeState(channel, message.params.data.state);
    state.resolve({
      accepted: true,
      signedTx: message.params.data.state
    });
    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 awaitingDepositTx(_x24, _x25, _x26) {
  return _awaitingDepositTx.apply(this, arguments);
}

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();
        }
      }
    }, _callee9);
  }));
  return _awaitingDepositTx.apply(this, arguments);
}

export function awaitingDepositCompletion(channel, message, state) {
  if (message.method === 'channels.on_chain_tx') {
    if (state.onOnChainTx) {
      state.onOnChainTx(message.params.data.tx);
    }

    return {
      handler: awaitingDepositCompletion,
      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 = {
        own_deposit_locked: state.onOwnDepositLocked,
        deposit_locked: state.onDepositLocked
      }[message.params.data.event];

      if (callback) {
        callback();
      }

      return {
        handler: awaitingDepositCompletion,
        state: state
      };
    }
  }

  if (message.method === 'channels.update') {
    changeState(channel, message.params.data.state);
    state.resolve({
      accepted: true,
      signedTx: message.params.data.state
    });
    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 awaitingNewContractTx(_x27, _x28, _x29) {
  return _awaitingNewContractTx.apply(this, arguments);
}

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();
        }
      }
    }, _callee10);
  }));
  return _awaitingNewContractTx.apply(this, arguments);
}

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)[{
      initiator: 'initiatorId',
      responder: 'responderId'
    }[options.get(channel).role]];
    changeState(channel, message.params.data.state);
    state.resolve({
      accepted: true,
      address: encodeContractAddress(owner, round),
      signedTx: message.params.data.state
    });
    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 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();
        }
      }
    }, _callee11);
  }));
  return _awaitingCallContractUpdateTx.apply(this, arguments);
}

export function awaitingCallContractForceProgressUpdate(_x33, _x34, _x35) {
  return _awaitingCallContractForceProgressUpdate.apply(this, arguments);
}

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();
        }
      }
    }, _callee12);
  }));
  return _awaitingCallContractForceProgressUpdate.apply(this, arguments);
}

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);
    }

    emit(channel, 'onChainTx', message.params.data.tx, {
      info: message.params.data.info,
      type: message.params.data.type
    });
    state.resolve({
      accepted: true,
      tx: message.params.data.tx
    });
  }

  return handleUnexpectedMessage(channel, message, state);
}
export function awaitingCallContractCompletion(channel, message, state) {
  if (message.method === 'channels.update') {
    changeState(channel, message.params.data.state);
    state.resolve({
      accepted: true,
      signedTx: message.params.data.state
    });
    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 awaitingCallsPruned(channels, message, state) {
  if (message.method === 'channels.calls_pruned.reply') {
    state.resolve();
    return {
      handler: channelOpen
    };
  }

  state.reject(new Error('Unexpected message received'));
  return {
    handler: channelClosed
  };
}
export function channelClosed(channel, message, state) {
  if (!state) return {
    handler: channelClosed
  };
  if (message.params.data.event === 'closing') return {
    handler: channelClosed,
    state: state
  };

  if (message.params.data.info === 'channel_closed') {
    state.closeTx = message.params.data.tx;
    return {
      handler: channelClosed,
      state: state
    };
  }

  if (message.params.data.event === 'closed_confirmed') {
    state.resolve(state.closeTx);
    return {
      handler: channelClosed
    };
  }

  return {
    handler: channelClosed,
    state: state
  };
}
//# sourceMappingURL=handlers.js.map