@aeternity/aepp-sdk 12.1.3 → 13.0.0-alpha.1

package/es/channel/handlers.mjs

@@ -1,5 +1,3 @@
-import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
-
 /*
  * ISC License (ISC)
  * Copyright (c) 2018 aeternity developers
@@ -16,41 +14,48 @@ import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/ins
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-
 /* eslint-disable consistent-return */
-
 /* eslint-disable default-case */
-
 /* eslint-disable @typescript-eslint/no-use-before-define */
-import { generateKeyPair, encodeContractAddress } from "../utils/crypto.mjs";
-import { options, changeStatus, changeState, call, send, emit, channelId, disconnect, fsmId } from "./internal.mjs";
+import { changeStatus, changeState, notify, emit, disconnect } from "./internal.mjs";
 import { unpackTx, buildTx } from "../tx/builder/index.mjs";
-import { encode, Encoding } from "../utils/encoder.mjs";
-import { IllegalArgumentError, InsufficientBalanceError, ChannelConnectionError, UnexpectedChannelMessageError } from "../utils/errors.mjs";
+import { decode } from "../utils/encoder.mjs";
+import { IllegalArgumentError, InsufficientBalanceError, ChannelConnectionError, UnexpectedChannelMessageError, ChannelError } from "../utils/errors.mjs";
 import { Tag } from "../tx/builder/constants.mjs";
 export async function appendSignature(tx, signFn) {
   const {
     signatures,
     encodedTx
-  } = unpackTx(tx, Tag.SignedTx).tx;
-  const result = await signFn(encode(encodedTx.rlpEncoded, Encoding.Transaction));
-
+  } = unpackTx(tx, Tag.SignedTx);
+  const payloadTx = buildTx(encodedTx);
+  const result = await signFn(payloadTx);
   if (typeof result === 'string') {
     const {
-      tx: signedTx
+      signatures: signatures2
     } = unpackTx(result, Tag.SignedTx);
     return buildTx({
-      signatures: signatures.concat(signedTx.signatures),
-      encodedTx: signedTx.encodedTx.rlpEncoded
-    }, Tag.SignedTx).tx;
+      tag: Tag.SignedTx,
+      signatures: signatures.concat(signatures2),
+      encodedTx: decode(payloadTx)
+    });
   }
-
   return result;
 }
-
-function handleUnexpectedMessage(_channel, message, state) {
+export async function signAndNotify(channel, method, data, signFn) {
+  var _signedTx;
+  let signedTx;
+  if (data.tx != null) signedTx = await signFn(data.tx);else if (data.signed_tx != null) signedTx = await appendSignature(data.signed_tx, signFn);else throw new ChannelError('Can\'t find transaction in message');
+  const isError = typeof signedTx !== 'string';
+  const key = data.tx != null ? 'tx' : 'signed_tx';
+  notify(channel, method, isError ? {
+    error: (_signedTx = signedTx) !== null && _signedTx !== void 0 ? _signedTx : 1
+  } : {
+    [key]: signedTx
+  });
+  return isError;
+}
+export function handleUnexpectedMessage(_channel, message, state) {
   var _state$reject;
-
   state === null || state === void 0 ? void 0 : (_state$reject = state.reject) === null || _state$reject === void 0 ? void 0 : _state$reject.call(state, Object.assign(new UnexpectedChannelMessageError(`Unexpected message received:\n\n${JSON.stringify(message)}`), {
     wsMessage: message
   }));
@@ -58,44 +63,74 @@ function handleUnexpectedMessage(_channel, message, state) {
     handler: channelOpen
   };
 }
-
+export function awaitingCompletion(channel, message, state, onSuccess) {
+  if (onSuccess != null && message.method === 'channels.update') {
+    return onSuccess(channel, message, state);
+  }
+  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 != null) {
+    const codes = message.error.data.map(d => d.code);
+    if (codes.includes(1001)) {
+      state.reject(new InsufficientBalanceError('Insufficient balance'));
+    } else if (codes.includes(1002)) {
+      state.reject(new IllegalArgumentError('Amount cannot be negative'));
+    } else {
+      state.reject(new ChannelConnectionError(message.error.message));
+    }
+    return {
+      handler: channelOpen
+    };
+  }
+  return handleUnexpectedMessage(channel, message, state);
+}
 export function awaitingConnection(channel, message) {
   if (message.method === 'channels.info') {
-    var _context;
-
     const channelInfoStatus = message.params.data.event;
-
-    if (_includesInstanceProperty(_context = ['channel_accept', 'funding_created']).call(_context, channelInfoStatus)) {
-      changeStatus(channel, {
-        channel_accept: 'accepted',
-        funding_created: 'halfSigned'
-      }[channelInfoStatus]);
+    let nextStatus = null;
+    if (channelInfoStatus === 'channel_accept') nextStatus = 'accepted';
+    if (channelInfoStatus === 'funding_created') nextStatus = 'halfSigned';
+    if (nextStatus != null) {
+      changeStatus(channel, nextStatus);
       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);
+      channel._fsmId = message.params.data.fsm_id;
       return {
         handler: awaitingConnection
       };
     }
-
     return {
       handler: awaitingConnection
     };
   }
-
   if (message.method === 'channels.error') {
     var _message$payload;
-
     emit(channel, 'error', new ChannelConnectionError(message === null || message === void 0 ? void 0 : (_message$payload = message.payload) === null || _message$payload === void 0 ? void 0 : _message$payload.message));
     return {
       handler: channelClosed
@@ -105,120 +140,82 @@ export function awaitingConnection(channel, message) {
 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);
+      channel._fsmId = message.params.data.fsm_id;
+      changeState(channel, (await channel.state()).signedTx);
       return {
         handler: channelOpen
       };
     }
   }
-
   return handleUnexpectedMessage(channel, message, state);
 }
 export async function awaitingChannelCreateTx(channel, message) {
-  const channelOptions = options.get(channel);
-
-  if (channelOptions != null) {
-    const tag = {
-      initiator: 'initiator_sign',
-      responder: 'responder_sign'
-    }[channelOptions.role];
-
-    if (message.method === `channels.sign.${tag}`) {
-      if (message.params.data.tx != null) {
-        const signedTx = await channelOptions.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, async tx => channelOptions.sign(tag, tx));
-      send(channel, {
-        jsonrpc: '2.0',
-        method: `channels.${tag}`,
-        params: {
-          signed_tx: signedTx
-        }
-      });
-      return {
-        handler: awaitingOnChainTx
-      };
-    }
+  const tag = channel._options.role === 'initiator' ? 'initiator_sign' : 'responder_sign';
+  if (message.method === `channels.sign.${tag}`) {
+    await signAndNotify(channel, `channels.${tag}`, message.params.data, async tx => channel._options.sign(tag, tx));
+    return {
+      handler: awaitingOnChainTx
+    };
   }
 }
 export function awaitingOnChainTx(channel, message) {
-  const channelOptions = options.get(channel);
-
-  if (channelOptions != null) {
-    if (message.method === 'channels.on_chain_tx') {
-      if (message.params.data.info === 'funding_signed' && channelOptions.role === 'initiator') {
-        return {
-          handler: awaitingBlockInclusion
-        };
-      }
-
-      if (message.params.data.info === 'funding_created' && channelOptions.role === 'responder') {
-        return {
-          handler: awaitingBlockInclusion
-        };
+  function awaitingBlockInclusion(_, message2) {
+    if (message2.method === 'channels.info') {
+      switch (message2.params.data.event) {
+        case 'funding_created':
+        case 'own_funding_locked':
+          return {
+            handler: awaitingBlockInclusion
+          };
+        case 'funding_locked':
+          return {
+            handler: awaitingOpenConfirmation
+          };
       }
     }
-
-    if (message.method === 'channels.info' && message.params.data.event === 'funding_signed' && channelOptions.role === 'initiator') {
-      channelId.set(channel, message.params.channel_id);
-      changeStatus(channel, 'signed');
+    if (message2.method === 'channels.on_chain_tx') {
+      emit(channel, 'onChainTx', message2.params.data.tx, {
+        info: message2.params.data.info,
+        type: message2.params.data.type
+      });
       return {
-        handler: awaitingOnChainTx
+        handler: awaitingBlockInclusion
       };
     }
   }
-}
-export function awaitingBlockInclusion(channel, message) {
-  if (message.method === 'channels.info') {
-    const handlers = {
-      funding_created: awaitingBlockInclusion,
-      own_funding_locked: awaitingBlockInclusion,
-      funding_locked: awaitingOpenConfirmation
-    };
-    const handler = handlers[message.params.data.event];
-
-    if (handler != null) {
+  if (message.method === 'channels.on_chain_tx') {
+    const {
+      info
+    } = message.params.data;
+    const {
+      role
+    } = channel._options;
+    if (info === 'funding_signed' && role === 'initiator' || info === 'funding_created' && role === 'responder') {
       return {
-        handler
+        handler: awaitingBlockInclusion
       };
     }
   }
-
-  if (message.method === 'channels.on_chain_tx') {
-    emit(channel, 'onChainTx', message.params.data.tx, {
-      info: message.params.data.info,
-      type: message.params.data.type
-    });
+  if (message.method === 'channels.info' && message.params.data.event === 'funding_signed' && channel._options.role === 'initiator') {
+    channel._channelId = message.params.channel_id;
+    changeStatus(channel, 'signed');
     return {
-      handler: awaitingBlockInclusion
+      handler: awaitingOnChainTx
     };
   }
 }
-export function awaitingOpenConfirmation(channel, message) {
+function awaitingOpenConfirmation(channel, message) {
   if (message.method === 'channels.info' && message.params.data.event === 'open') {
-    channelId.set(channel, message.params.channel_id);
+    channel._channelId = message.params.channel_id;
     return {
-      handler: awaitingInitialState
-    };
-  }
-}
-export function awaitingInitialState(channel, message) {
-  if (message.method === 'channels.update') {
-    changeState(channel, message.params.data.state);
-    return {
-      handler: channelOpen
+      handler(_, message2) {
+        if (message2.method === 'channels.update') {
+          changeState(channel, message2.params.data.state);
+          return {
+            handler: channelOpen
+          };
+        }
+      }
     };
   }
 }
@@ -232,7 +229,6 @@ export async function channelOpen(channel, message, state) {
           return {
             handler: awaitingTxSignRequest
           };
-
         case 'own_withdraw_locked':
         case 'withdraw_locked':
         case 'own_deposit_locked':
@@ -248,45 +244,37 @@ export async function channelOpen(channel, message, state) {
           return {
             handler: channelOpen
           };
-
         case 'fsm_up':
-          fsmId.set(channel, message.params.data.fsm_id);
+          channel._fsmId = 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
           };
       }
-
       break;
-
     case 'channels.on_chain_tx':
       emit(channel, 'onChainTx', message.params.data.tx, {
         info: message.params.data.info,
@@ -295,314 +283,69 @@ export async function channelOpen(channel, message, state) {
       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 = channel => {
   changeStatus(channel, 'open');
 };
-
-export async function awaitingOffChainTx(channel, message, state) {
-  if (message.method === 'channels.sign.update') {
-    const {
-      sign
-    } = state;
-
-    if (message.params.data.tx != null) {
-      const signedTx = await sign(message.params.data.tx, {
-        updates: message.params.data.updates
-      });
-      send(channel, {
-        jsonrpc: '2.0',
-        method: 'channels.update',
-        params: {
-          tx: signedTx
-        }
-      });
-      return {
-        handler: awaitingOffChainUpdate,
-        state
-      };
-    }
-
-    const signedTx = await appendSignature(message.params.data.signed_tx, async 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
-        }
-      });
+async function awaitingTxSignRequest(channel, message, state) {
+  var _message$method$match;
+  const [, tag] = (_message$method$match = message.method.match(/^channels\.sign\.([^.]+)$/)) !== null && _message$method$match !== void 0 ? _message$method$match : [];
+  if (tag == null) return handleUnexpectedMessage(channel, message, state);
+  const isError = await signAndNotify(channel, `channels.${tag}`, message.params.data, async tx => channel._options.sign(tag, tx, {
+    updates: message.params.data.updates
+  }));
+  function awaitingUpdateConflict(_, message2) {
+    if (message2.error != null) {
       return {
-        handler: awaitingOffChainTx,
+        handler: awaitingUpdateConflict,
         state
       };
     }
-  }
-
-  if (message.method === 'channels.error') {
-    state.reject(new ChannelConnectionError(message.data.message));
-    return {
-      handler: channelOpen
-    };
-  }
-
-  if (message.error != null) {
-    var _message$error;
-
-    const {
-      data
-    } = (_message$error = message.error) !== null && _message$error !== void 0 ? _message$error : {
-      data: []
-    };
-
-    if (data.find(i => i.code === 1001) != null) {
-      state.reject(new InsufficientBalanceError('Insufficient balance'));
-    } else if (data.find(i => i.code === 1002) != null) {
-      state.reject(new IllegalArgumentError('Amount cannot be negative'));
-    } else {
-      state.reject(new ChannelConnectionError(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
-      });
+    if (message2.method === 'channels.conflict') {
       return {
         handler: channelOpen
       };
     }
+    return handleUnexpectedMessage(channel, message2, state);
   }
-
-  return handleUnexpectedMessage(channel, message, state);
+  return isError ? {
+    handler: awaitingUpdateConflict,
+    state
+  } : {
+    handler: channelOpen
+  };
 }
-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 != null) {
-    state.reject(new ChannelConnectionError(message.error.message));
-    return {
-      handler: channelOpen
-    };
+export async function awaitingShutdownTx(channel, message, state) {
+  if (message.method !== 'channels.sign.shutdown_sign') {
+    return handleUnexpectedMessage(channel, message, state);
   }
-
-  return handleUnexpectedMessage(channel, message, state);
-}
-export async function awaitingTxSignRequest(channel, message, state) {
-  var _message$method$match;
-
-  const [, tag] = (_message$method$match = message.method.match(/^channels\.sign\.([^.]+)$/)) !== null && _message$method$match !== void 0 ? _message$method$match : [];
-  const channelOptions = options.get(channel);
-
-  if (tag != null && channelOptions != null) {
-    if (message.params.data.tx != null) {
-      const signedTx = await channelOptions.sign(tag, message.params.data.tx, {
-        updates: message.params.data.updates
-      });
-
-      if (signedTx != null) {
-        send(channel, {
-          jsonrpc: '2.0',
-          method: `channels.${tag}`,
-          params: {
-            tx: signedTx
-          }
-        });
-        return {
-          handler: channelOpen
-        };
-      }
-    } else {
-      const signedTx = await appendSignature(message.params.data.signed_tx, async tx => channelOptions.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
+  await signAndNotify(channel, 'channels.shutdown_sign', message.params.data, async tx => state.sign(tx));
+  return {
+    handler(_, message2) {
+      if (message2.method !== 'channels.on_chain_tx') {
+        return handleUnexpectedMessage(channel, message2, state);
       }
-    });
-    return {
-      handler: awaitingUpdateConflict,
-      state
-    };
-  }
-
-  return handleUnexpectedMessage(channel, message, state);
-}
-export function awaitingUpdateConflict(channel, message, state) {
-  if (message.error != null) {
-    return {
-      handler: awaitingUpdateConflict,
-      state
-    };
-  }
-
-  if (message.method === 'channels.conflict') {
-    return {
-      handler: channelOpen
-    };
-  }
-
-  return handleUnexpectedMessage(channel, message, state);
-}
-export async function awaitingShutdownTx(channel, message, state) {
-  if (message.method === 'channels.sign.shutdown_sign') {
-    if (message.params.data.tx != null) {
-      const signedTx = await state.sign(message.params.data.tx);
-      send(channel, {
-        jsonrpc: '2.0',
-        method: 'channels.shutdown_sign',
-        params: {
-          tx: signedTx
-        }
-      });
+      // state.resolve(message.params.data.tx)
       return {
-        handler: awaitingShutdownOnChainTx,
+        handler: channelClosed,
         state
       };
-    }
-
-    const signedTx = await appendSignature(message.params.data.signed_tx, async tx => state.sign(tx));
-    send(channel, {
-      jsonrpc: '2.0',
-      method: 'channels.shutdown_sign',
-      params: {
-        signed_tx: signedTx
-      }
-    });
-    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
-    };
-  }
-
-  return handleUnexpectedMessage(channel, message, state);
+    },
+    state
+  };
 }
 export function awaitingLeave(channel, message, state) {
   if (message.method === 'channels.leave') {
@@ -615,502 +358,14 @@ export function awaitingLeave(channel, message, state) {
       handler: channelClosed
     };
   }
-
   if (message.method === 'channels.error') {
     state.reject(new ChannelConnectionError(message.data.message));
     return {
       handler: channelOpen
     };
   }
-
   return handleUnexpectedMessage(channel, message, state);
 }
-export async function awaitingWithdrawTx(channel, message, state) {
-  if (message.method === 'channels.sign.withdraw_tx') {
-    const {
-      sign
-    } = state;
-
-    if (message.params.data.tx != null) {
-      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
-      };
-    }
-
-    const signedTx = await appendSignature(message.params.data.signed_tx, async 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
-        }
-      });
-      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') {
-    var _state$onOnChainTx;
-
-    (_state$onOnChainTx = state.onOnChainTx) === null || _state$onOnChainTx === void 0 ? void 0 : _state$onOnChainTx.call(state, message.params.data.tx);
-    return {
-      handler: awaitingWithdrawCompletion,
-      state
-    };
-  }
-
-  if (message.method === 'channels.info') {
-    var _context2;
-
-    if (_includesInstanceProperty(_context2 = ['own_withdraw_locked', 'withdraw_locked']).call(_context2, message.params.data.event)) {
-      var _callbacks$message$pa;
-
-      const callbacks = {
-        own_withdraw_locked: state.onOwnWithdrawLocked,
-        withdraw_locked: state.onWithdrawLocked
-      };
-      (_callbacks$message$pa = callbacks[message.params.data.event]) === null || _callbacks$message$pa === void 0 ? void 0 : _callbacks$message$pa.call(callbacks);
-      return {
-        handler: awaitingWithdrawCompletion,
-        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 async function awaitingDepositTx(channel, message, state) {
-  if (message.method === 'channels.sign.deposit_tx') {
-    const {
-      sign
-    } = state;
-
-    if (message.params.data.tx != null) {
-      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
-      };
-    }
-
-    const signedTx = await appendSignature(message.params.data.signed_tx, async 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
-        }
-      });
-      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') {
-    var _state$onOnChainTx2;
-
-    (_state$onOnChainTx2 = state.onOnChainTx) === null || _state$onOnChainTx2 === void 0 ? void 0 : _state$onOnChainTx2.call(state, message.params.data.tx);
-    return {
-      handler: awaitingDepositCompletion,
-      state
-    };
-  }
-
-  if (message.method === 'channels.info') {
-    var _context3;
-
-    if (_includesInstanceProperty(_context3 = ['own_deposit_locked', 'deposit_locked']).call(_context3, message.params.data.event)) {
-      var _callbacks$message$pa2;
-
-      const callbacks = {
-        own_deposit_locked: state.onOwnDepositLocked,
-        deposit_locked: state.onDepositLocked
-      };
-      (_callbacks$message$pa2 = callbacks[message.params.data.event]) === null || _callbacks$message$pa2 === void 0 ? void 0 : _callbacks$message$pa2.call(callbacks);
-      return {
-        handler: awaitingDepositCompletion,
-        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 async function awaitingNewContractTx(channel, message, state) {
-  if (message.method === 'channels.sign.update') {
-    if (message.params.data.tx != null) {
-      const signedTx = await state.sign(message.params.data.tx);
-      send(channel, {
-        jsonrpc: '2.0',
-        method: 'channels.update',
-        params: {
-          tx: signedTx
-        }
-      });
-      return {
-        handler: awaitingNewContractCompletion,
-        state
-      };
-    }
-
-    const signedTx = await appendSignature(message.params.data.signed_tx, async tx => state.sign(tx));
-
-    if (typeof signedTx === 'string') {
-      send(channel, {
-        jsonrpc: '2.0',
-        method: 'channels.update',
-        params: {
-          signed_tx: signedTx
-        }
-      });
-      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) {
-  const channelOptions = options.get(channel);
-
-  if (message.method === 'channels.update') {
-    const {
-      round
-    } = unpackTx(message.params.data.state, Tag.SignedTx).tx.encodedTx.tx;
-
-    if ((channelOptions === null || channelOptions === void 0 ? void 0 : channelOptions.role) != null) {
-      let role = null;
-      if (channelOptions.role === 'initiator') role = 'initiatorId';
-      if (channelOptions.role === 'responder') role = 'responderId';
-
-      if (role != null) {
-        const owner = channelOptions === null || channelOptions === void 0 ? void 0 : channelOptions[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 async function awaitingCallContractUpdateTx(channel, message, state) {
-  if (message.method === 'channels.sign.update') {
-    if (message.params.data.tx != null) {
-      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
-        }
-      });
-      return {
-        handler: awaitingCallContractCompletion,
-        state
-      };
-    }
-
-    const signedTx = await appendSignature(message.params.data.signed_tx, async tx => state.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: 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, async 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) {
-  if (message.method === 'channels.on_chain_tx') {
-    var _state$onOnChainTx3;
-
-    (_state$onOnChainTx3 = state.onOnChainTx) === null || _state$onOnChainTx3 === void 0 ? void 0 : _state$onOnChainTx3.call(state, message.params.data.tx);
-    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 UnexpectedChannelMessageError('Unexpected message received'));
-  return {
-    handler: channelClosed
-  };
-}
 export function channelClosed(_channel, message, state) {
   if (state == null) return {
     handler: channelClosed
@@ -1119,7 +374,6 @@ export function channelClosed(_channel, message, state) {
     handler: channelClosed,
     state
   };
-
   if (message.params.data.info === 'channel_closed') {
     state.closeTx = message.params.data.tx;
     return {
@@ -1127,14 +381,12 @@ export function channelClosed(_channel, message, state) {
       state
     };
   }
-
   if (message.params.data.event === 'closed_confirmed') {
     state.resolve(state.closeTx);
     return {
       handler: channelClosed
     };
   }
-
   return {
     handler: channelClosed,
     state