@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/src/channel/{handlers.js → handlers.ts}

@@ -15,8 +15,9 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import { generateKeyPair, encodeContractAddress, encodeBase64Check } from '../utils/crypto'
+import { generateKeyPair, encodeContractAddress } from '../utils/crypto'
 import {
+  ChannelState,
   options,
   changeStatus,
   changeState,
@@ -25,44 +26,60 @@ import {
   emit,
   channelId,
   disconnect,
-  fsmId
+  fsmId,
+  ChannelMessage,
+  ChannelFsm,
+  SignTx
 } from './internal'
 import { unpackTx, buildTx } from '../tx/builder'
+import { encode } from '../tx/builder/helpers'
+import { EncodedData } from '../utils/encoder'
+import {
+  IllegalArgumentError,
+  InsufficientBalanceError,
+  ChannelConnectionError,
+  UnexpectedChannelMessageError
+} from '../utils/errors'
+import Channel from '.'
+import { TX_TYPE } from '../tx/builder/schema'
 
-function encodeRlpTx (rlpBinary) {
-  return `tx_${encodeBase64Check(rlpBinary)}`
-}
-
-async function appendSignature (tx, signFn) {
-  const { signatures, encodedTx } = unpackTx(tx).tx
-  const result = await signFn(encodeRlpTx(encodedTx.rlpEncoded))
+export async function appendSignature (
+  tx: EncodedData<'tx'>, signFn: SignTx
+): Promise<EncodedData<'tx'> | number | null> {
+  const { signatures, encodedTx } = unpackTx(tx, TX_TYPE.signed).tx
+  const result = await signFn(encode(encodedTx.rlpEncoded, 'tx'))
   if (typeof result === 'string') {
-    const { tx: signedTx, txType } = unpackTx(result)
-    return encodeRlpTx(buildTx({
+    const { tx: signedTx } = unpackTx(result, TX_TYPE.signed)
+    return buildTx({
       signatures: signatures.concat(signedTx.signatures),
       encodedTx: signedTx.encodedTx.rlpEncoded
-    }, txType).rlpEncoded)
+    }, TX_TYPE.signed).tx
   }
   return result
 }
 
-function handleUnexpectedMessage (channel, message, state) {
-  if (state && state.reject) {
+function handleUnexpectedMessage (
+  _channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
+  if (state?.reject != null) {
     state.reject(Object.assign(
-      new Error(`Unexpected message received:\n\n${JSON.stringify(message)}`),
+      new UnexpectedChannelMessageError(`Unexpected message received:\n\n${JSON.stringify(message)}`),
       { wsMessage: message }
     ))
   }
   return { handler: channelOpen }
 }
 
-export function awaitingConnection (channel, message, state) {
+export function awaitingConnection (
+  channel: Channel, message: ChannelMessage
+): ChannelFsm | undefined {
   if (message.method === 'channels.info') {
-    if (['channel_accept', 'funding_created'].includes(message.params.data.event)) {
+    const channelInfoStatus: string = message.params.data.event
+    if (['channel_accept', 'funding_created'].includes(channelInfoStatus)) {
       changeStatus(channel, {
         channel_accept: 'accepted',
         funding_created: 'halfSigned'
-      }[message.params.data.event])
+      }[channelInfoStatus as 'channel_accept' | 'funding_created'])
       return { handler: awaitingChannelCreateTx }
     }
     if (message.params.data.event === 'channel_reestablished') {
@@ -75,12 +92,14 @@ export function awaitingConnection (channel, message, state) {
     return { handler: awaitingConnection }
   }
   if (message.method === 'channels.error') {
-    emit(channel, 'error', new Error(message.payload.message))
+    emit(channel, 'error', new ChannelConnectionError(message?.payload?.message))
     return { handler: channelClosed }
   }
 }
 
-export async function awaitingReconnection (channel, message, state) {
+export async function awaitingReconnection (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm> {
   if (message.method === 'channels.info') {
     if (message.params.data.event === 'fsm_up') {
       fsmId.set(channel, message.params.data.fsm_id)
@@ -91,59 +110,74 @@ export async function awaitingReconnection (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-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 } })
+export async function awaitingChannelCreateTx (
+  channel: Channel, message: ChannelMessage
+): Promise<ChannelFsm | undefined> {
+  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 => await channelOptions.sign(tag, tx)
+      )
+      send(channel, { jsonrpc: '2.0', method: `channels.${tag}`, params: { signed_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 } })
-    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'
-    ) {
-      return { handler: awaitingBlockInclusion }
+export function awaitingOnChainTx (
+  channel: Channel, message: ChannelMessage
+): ChannelFsm | undefined {
+  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 }
+      }
     }
     if (
-      message.params.data.info === 'funding_created' &&
-      options.get(channel).role === 'responder'
+      message.method === 'channels.info' &&
+    message.params.data.event === 'funding_signed' &&
+    channelOptions.role === 'initiator'
     ) {
-      return { handler: awaitingBlockInclusion }
+      channelId.set(channel, message.params.channel_id)
+      changeStatus(channel, 'signed')
+      return { handler: awaitingOnChainTx }
     }
   }
-  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) {
+export function awaitingBlockInclusion (
+  channel: Channel, message: ChannelMessage
+): ChannelFsm | undefined {
   if (message.method === 'channels.info') {
-    const handler = {
+    const handlers: {
+      [key: string]: (channel: Channel, message: ChannelMessage) => ChannelFsm | undefined
+    } = {
       funding_created: awaitingBlockInclusion,
       own_funding_locked: awaitingBlockInclusion,
       funding_locked: awaitingOpenConfirmation
-    }[message.params.data.event]
-    if (handler) {
+    }
+    const handler = handlers[message.params.data.event as string]
+    if (handler != null) {
       return { handler }
     }
   }
@@ -156,21 +190,27 @@ export function awaitingBlockInclusion (channel, message, state) {
   }
 }
 
-export function awaitingOpenConfirmation (channel, message, state) {
+export function awaitingOpenConfirmation (
+  channel: Channel, message: ChannelMessage
+): ChannelFsm | undefined {
   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) {
+export function awaitingInitialState (
+  channel: Channel, message: ChannelMessage
+): ChannelFsm | undefined {
   if (message.method === 'channels.update') {
     changeState(channel, message.params.data.state)
     return { handler: channelOpen }
   }
 }
 
-export async function channelOpen (channel, message, state) {
+export async function channelOpen (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm | undefined> {
   switch (message.method) {
     case 'channels.info':
       switch (message.params.data.event) {
@@ -223,23 +263,26 @@ export async function channelOpen (channel, message, state) {
       changeState(channel, message.params.data.state)
       return { handler: channelOpen }
     case 'channels.sign.shutdown_sign_ack':
-      return awaitingTxSignRequest(channel, message, state)
+      return await awaitingTxSignRequest(channel, message, state)
   }
 }
-channelOpen.enter = (channel) => {
+channelOpen.enter = (channel: Channel) => {
   changeStatus(channel, 'open')
 }
 
-export async function awaitingOffChainTx (channel, message, state) {
+export async function awaitingOffChainTx (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm> {
   if (message.method === 'channels.sign.update') {
     const { sign } = state
-    if (message.params.data.tx) {
-      const signedTx = await sign(message.params.data.tx, { updates: message.params.data.updates })
+    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, tx =>
-      sign(tx, { updates: message.params.data.updates })
+    const signedTx = await appendSignature(message.params.data.signed_tx, async tx =>
+      await sign(tx, { updates: message.params.data.updates })
     )
     if (typeof signedTx === 'string') {
       send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { signed_tx: signedTx } })
@@ -251,17 +294,17 @@ export async function awaitingOffChainTx (channel, message, state) {
     }
   }
   if (message.method === 'channels.error') {
-    state.reject(new Error(message.data.message))
+    state.reject(new ChannelConnectionError(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'))
+  if (message.error != null) {
+    const { data } = 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 Error(message.error.message))
+      state.reject(new ChannelConnectionError(message.error.message))
     }
     return { handler: channelOpen }
   }
@@ -282,7 +325,9 @@ export async function awaitingOffChainTx (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export function awaitingOffChainUpdate (channel, message, state) {
+export function awaitingOffChainUpdate (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm | undefined {
   if (message.method === 'channels.update') {
     changeState(channel, message.params.data.state)
     state.resolve({ accepted: true, signedTx: message.params.data.state })
@@ -302,27 +347,30 @@ export function awaitingOffChainUpdate (channel, message, state) {
       return { handler: channelOpen }
     }
   }
-  if (message.error) {
-    state.reject(new Error(message.error.message))
+  if (message.error != null) {
+    state.reject(new ChannelConnectionError(message.error.message))
     return { handler: channelOpen }
   }
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export async function awaitingTxSignRequest (channel, message, state) {
-  const [, tag] = message.method.match(/^channels\.sign\.([^.]+)$/) || []
-  if (tag) {
-    if (message.params.data.tx) {
-      const signedTx = await options.get(channel).sign(tag, message.params.data.tx, {
+export async function awaitingTxSignRequest (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm | undefined> {
+  const [, tag] = message.method.match(/^channels\.sign\.([^.]+)$/) ?? []
+  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) {
+      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, tx =>
-        options.get(channel).sign(tag, tx, { updates: message.params.data.updates })
+      const signedTx = await appendSignature(message.params.data.signed_tx, async tx =>
+        await 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 } })
@@ -348,8 +396,10 @@ export async function awaitingTxSignRequest (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export function awaitingUpdateConflict (channel, message, state) {
-  if (message.error) {
+export function awaitingUpdateConflict (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
+  if (message.error != null) {
     return { handler: awaitingUpdateConflict, state }
   }
   if (message.method === 'channels.conflict') {
@@ -358,21 +408,26 @@ export function awaitingUpdateConflict (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export async function awaitingShutdownTx (channel, message, state) {
+export async function awaitingShutdownTx (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm | undefined> {
   if (message.method === 'channels.sign.shutdown_sign') {
-    if (message.params.data.tx) {
+    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 } })
       return { handler: awaitingShutdownOnChainTx, state }
     }
-    const signedTx = await appendSignature(message.params.data.signed_tx, tx => state.sign(tx))
+    const signedTx = await appendSignature(message.params.data.signed_tx, async tx =>
+      await 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) {
+export function awaitingShutdownOnChainTx (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
   if (message.method === 'channels.on_chain_tx') {
     // state.resolve(message.params.data.tx)
     return { handler: channelClosed, state }
@@ -380,29 +435,34 @@ export function awaitingShutdownOnChainTx (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export function awaitingLeave (channel, message, state) {
+export function awaitingLeave (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
   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))
+    state.reject(new ChannelConnectionError(message.data.message))
     return { handler: channelOpen }
   }
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export async function awaitingWithdrawTx (channel, message, state) {
+export async function awaitingWithdrawTx (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm | undefined> {
   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 })
+    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, tx =>
-      sign(tx, { updates: message.params.data.updates })
+    const signedTx = await appendSignature(message.params.data.signed_tx, async tx =>
+      await sign(tx, { updates: message.params.data.updates })
     )
     if (typeof signedTx === 'string') {
       send(channel, { jsonrpc: '2.0', method: 'channels.withdraw_tx', params: { signed_tx: signedTx } })
@@ -416,20 +476,25 @@ export async function awaitingWithdrawTx (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export function awaitingWithdrawCompletion (channel, message, state) {
+export function awaitingWithdrawCompletion (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
   if (message.method === 'channels.on_chain_tx') {
-    if (state.onOnChainTx) {
+    if (state.onOnChainTx != null) {
       state.onOnChainTx(message.params.data.tx)
     }
     return { handler: awaitingWithdrawCompletion, state }
   }
   if (message.method === 'channels.info') {
     if (['own_withdraw_locked', 'withdraw_locked'].includes(message.params.data.event)) {
-      const callback = {
+      const callbacks: {
+        [key: string]: Function | undefined
+      } = {
         own_withdraw_locked: state.onOwnWithdrawLocked,
         withdraw_locked: state.onWithdrawLocked
-      }[message.params.data.event]
-      if (callback) {
+      }
+      const callback = callbacks[message.params.data.event]
+      if (callback != null) {
         callback()
       }
       return { handler: awaitingWithdrawCompletion, state }
@@ -457,16 +522,19 @@ export function awaitingWithdrawCompletion (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export async function awaitingDepositTx (channel, message, state) {
+export async function awaitingDepositTx (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm | undefined> {
   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 })
+    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, tx =>
-      sign(tx, { updates: message.params.data.updates })
+    const signedTx = await appendSignature(message.params.data.signed_tx, async tx =>
+      await sign(tx, { updates: message.params.data.updates })
     )
     if (typeof signedTx === 'string') {
       send(channel, { jsonrpc: '2.0', method: 'channels.deposit_tx', params: { signed_tx: signedTx } })
@@ -480,20 +548,25 @@ export async function awaitingDepositTx (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export function awaitingDepositCompletion (channel, message, state) {
+export function awaitingDepositCompletion (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
   if (message.method === 'channels.on_chain_tx') {
-    if (state.onOnChainTx) {
+    if (state.onOnChainTx != null) {
       state.onOnChainTx(message.params.data.tx)
     }
     return { handler: awaitingDepositCompletion, state }
   }
   if (message.method === 'channels.info') {
     if (['own_deposit_locked', 'deposit_locked'].includes(message.params.data.event)) {
-      const callback = {
+      const callbacks: {
+        [key: string]: Function | undefined
+      } = {
         own_deposit_locked: state.onOwnDepositLocked,
         deposit_locked: state.onDepositLocked
-      }[message.params.data.event]
-      if (callback) {
+      }
+      const callback = callbacks[message.params.data.event]
+      if (callback != null) {
         callback()
       }
       return { handler: awaitingDepositCompletion, state }
@@ -521,14 +594,17 @@ export function awaitingDepositCompletion (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export async function awaitingNewContractTx (channel, message, state) {
+export async function awaitingNewContractTx (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm | undefined> {
   if (message.method === 'channels.sign.update') {
-    if (message.params.data.tx) {
+    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, tx => state.sign(tx))
+    const signedTx = await appendSignature(message.params.data.signed_tx,
+      async tx => await state.sign(tx))
     if (typeof signedTx === 'string') {
       send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { signed_tx: signedTx } })
       return { handler: awaitingNewContractCompletion, state }
@@ -541,20 +617,27 @@ export async function awaitingNewContractTx (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export function awaitingNewContractCompletion (channel, message, state) {
+export function awaitingNewContractCompletion (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
+  const channelOptions = options.get(channel)
   if (message.method === 'channels.update') {
-    const { round } = unpackTx(message.params.data.state).tx.encodedTx.tx
-    const 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 }
+    const { round } = unpackTx(message.params.data.state, TX_TYPE.signed).tx.encodedTx.tx
+    if (channelOptions?.role != null) {
+      const role = channelOptions.role === 'initiator'
+        ? 'initiatorId'
+        : channelOptions.role === 'responder' ? 'responderId' : null
+      if (role != null) {
+        const owner = 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({
@@ -573,9 +656,11 @@ export function awaitingNewContractCompletion (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export async function awaitingCallContractUpdateTx (channel, message, state) {
+export async function awaitingCallContractUpdateTx (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm | undefined> {
   if (message.method === 'channels.sign.update') {
-    if (message.params.data.tx) {
+    if (message.params.data.tx != null) {
       const signedTx = await state.sign(
         message.params.data.tx, { updates: message.params.data.updates }
       )
@@ -584,7 +669,7 @@ export async function awaitingCallContractUpdateTx (channel, message, state) {
     }
     const signedTx = await appendSignature(
       message.params.data.signed_tx,
-      tx => state.sign(tx, { updates: message.params.data.updates })
+      async tx => await state.sign(tx, { updates: message.params.data.updates })
     )
     if (typeof signedTx === 'string') {
       send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { signed_tx: signedTx } })
@@ -598,10 +683,12 @@ export async function awaitingCallContractUpdateTx (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export async function awaitingCallContractForceProgressUpdate (channel, message, state) {
+export async function awaitingCallContractForceProgressUpdate (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): Promise<ChannelFsm | undefined> {
   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 })
+    const signedTx = await appendSignature(message.params.data.signed_tx, async tx =>
+      await 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 }
@@ -609,9 +696,11 @@ export async function awaitingCallContractForceProgressUpdate (channel, message,
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export function awaitingForceProgressCompletion (channel, message, state) {
+export function awaitingForceProgressCompletion (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
   if (message.method === 'channels.on_chain_tx') {
-    if (state.onOnChainTx) {
+    if (state.onOnChainTx != null) {
       state.onOnChainTx(message.params.data)
     }
     emit(channel, 'onChainTx', message.params.data.tx, {
@@ -623,7 +712,9 @@ export function awaitingForceProgressCompletion (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export function awaitingCallContractCompletion (channel, message, state) {
+export function awaitingCallContractCompletion (
+  channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
   if (message.method === 'channels.update') {
     changeState(channel, message.params.data.state)
     state.resolve({ accepted: true, signedTx: message.params.data.state })
@@ -646,17 +737,21 @@ export function awaitingCallContractCompletion (channel, message, state) {
   return handleUnexpectedMessage(channel, message, state)
 }
 
-export function awaitingCallsPruned (channels, message, state) {
+export function awaitingCallsPruned (
+  _channels: Channel[], message: ChannelMessage, state: ChannelState
+): ChannelFsm {
   if (message.method === 'channels.calls_pruned.reply') {
     state.resolve()
     return { handler: channelOpen }
   }
-  state.reject(new Error('Unexpected message received'))
+  state.reject(new UnexpectedChannelMessageError('Unexpected message received'))
   return { handler: channelClosed }
 }
 
-export function channelClosed (channel, message, state) {
-  if (!state) return { handler: channelClosed }
+export function channelClosed (
+  _channel: Channel, message: ChannelMessage, state: ChannelState
+): ChannelFsm {
+  if (state == null) return { handler: channelClosed }
   if (message.params.data.event === 'closing') return { handler: channelClosed, state }
   if (message.params.data.info === 'channel_closed') {
     state.closeTx = message.params.data.tx