@aeternity/aepp-sdk 11.0.1 → 12.1.1

package/es/channel/handlers.mjs

@@ -1,3 +1,5 @@
+import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
+
 /*
  * ISC License (ISC)
  * Copyright (c) 2018 aeternity developers
@@ -14,52 +16,60 @@
  *  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 { unpackTx, buildTx } from "../tx/builder/index.mjs";
-import { encode } from "../tx/builder/helpers.mjs";
+import { encode, Encoding } from "../utils/encoder.mjs";
 import { IllegalArgumentError, InsufficientBalanceError, ChannelConnectionError, UnexpectedChannelMessageError } from "../utils/errors.mjs";
-
-async function appendSignature(tx, signFn) {
+import { Tag } from "../tx/builder/constants.mjs";
+export async function appendSignature(tx, signFn) {
   const {
     signatures,
     encodedTx
-  } = unpackTx(tx).tx;
-  const result = await signFn(encode(encodedTx.rlpEncoded, 'tx'));
+  } = unpackTx(tx, Tag.SignedTx).tx;
+  const result = await signFn(encode(encodedTx.rlpEncoded, Encoding.Transaction));
 
   if (typeof result === 'string') {
     const {
-      tx: signedTx,
-      txType
-    } = unpackTx(result);
+      tx: signedTx
+    } = unpackTx(result, Tag.SignedTx);
     return buildTx({
       signatures: signatures.concat(signedTx.signatures),
       encodedTx: signedTx.encodedTx.rlpEncoded
-    }, txType).tx;
+    }, Tag.SignedTx).tx;
   }
 
   return result;
 }
 
-function handleUnexpectedMessage(channel, message, state) {
-  if (state && state.reject) {
-    state.reject(Object.assign(new UnexpectedChannelMessageError(`Unexpected message received:\n\n${JSON.stringify(message)}`), {
-      wsMessage: message
-    }));
-  }
+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
+  }));
   return {
     handler: channelOpen
   };
 }
 
-export function awaitingConnection(channel, message, state) {
+export function awaitingConnection(channel, message) {
   if (message.method === 'channels.info') {
-    if (['channel_accept', 'funding_created'].includes(message.params.data.event)) {
+    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'
-      }[message.params.data.event]);
+      }[channelInfoStatus]);
       return {
         handler: awaitingChannelCreateTx
       };
@@ -84,7 +94,9 @@ export function awaitingConnection(channel, message, state) {
   }
 
   if (message.method === 'channels.error') {
-    emit(channel, 'error', new ChannelConnectionError(message.payload.message));
+    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
     };
@@ -103,72 +115,81 @@ 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);
+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: {
-          tx: signedTx
+          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, 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
+        };
+      }
     }
 
-    if (message.params.data.info === 'funding_created' && options.get(channel).role === 'responder') {
+    if (message.method === 'channels.info' && message.params.data.event === 'funding_signed' && channelOptions.role === 'initiator') {
+      channelId.set(channel, message.params.channel_id);
+      changeStatus(channel, 'signed');
       return {
-        handler: awaitingBlockInclusion
+        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, message) {
   if (message.method === 'channels.info') {
-    const handler = {
+    const handlers = {
       funding_created: awaitingBlockInclusion,
       own_funding_locked: awaitingBlockInclusion,
       funding_locked: awaitingOpenConfirmation
-    }[message.params.data.event];
+    };
+    const handler = handlers[message.params.data.event];
 
-    if (handler) {
+    if (handler != null) {
       return {
         handler
       };
@@ -185,7 +206,7 @@ export function awaitingBlockInclusion(channel, message, state) {
     };
   }
 }
-export function awaitingOpenConfirmation(channel, message, state) {
+export function awaitingOpenConfirmation(channel, message) {
   if (message.method === 'channels.info' && message.params.data.event === 'open') {
     channelId.set(channel, message.params.channel_id);
     return {
@@ -193,7 +214,7 @@ export function awaitingOpenConfirmation(channel, message, state) {
     };
   }
 }
-export function awaitingInitialState(channel, message, state) {
+export function awaitingInitialState(channel, message) {
   if (message.method === 'channels.update') {
     changeState(channel, message.params.data.state);
     return {
@@ -302,7 +323,7 @@ export async function awaitingOffChainTx(channel, message, state) {
       sign
     } = state;
 
-    if (message.params.data.tx) {
+    if (message.params.data.tx != null) {
       const signedTx = await sign(message.params.data.tx, {
         updates: message.params.data.updates
       });
@@ -319,7 +340,7 @@ export async function awaitingOffChainTx(channel, message, state) {
       };
     }
 
-    const signedTx = await appendSignature(message.params.data.signed_tx, tx => sign(tx, {
+    const signedTx = await appendSignature(message.params.data.signed_tx, async tx => sign(tx, {
       updates: message.params.data.updates
     }));
 
@@ -359,14 +380,18 @@ export async function awaitingOffChainTx(channel, message, state) {
     };
   }
 
-  if (message.error) {
+  if (message.error != null) {
+    var _message$error;
+
     const {
-      data = []
-    } = message.error;
+      data
+    } = (_message$error = message.error) !== null && _message$error !== void 0 ? _message$error : {
+      data: []
+    };
 
-    if (data.find(i => i.code === 1001)) {
+    if (data.find(i => i.code === 1001) != null) {
       state.reject(new InsufficientBalanceError('Insufficient balance'));
-    } else if (data.find(i => i.code === 1002)) {
+    } 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));
@@ -435,7 +460,7 @@ export function awaitingOffChainUpdate(channel, message, state) {
     }
   }
 
-  if (message.error) {
+  if (message.error != null) {
     state.reject(new ChannelConnectionError(message.error.message));
     return {
       handler: channelOpen
@@ -445,15 +470,18 @@ export function awaitingOffChainUpdate(channel, message, state) {
   return handleUnexpectedMessage(channel, message, state);
 }
 export async function awaitingTxSignRequest(channel, message, state) {
-  const [, tag] = message.method.match(/^channels\.sign\.([^.]+)$/) || [];
+  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) {
-    if (message.params.data.tx) {
-      const signedTx = await options.get(channel).sign(tag, message.params.data.tx, {
+  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}`,
@@ -466,7 +494,7 @@ export async function awaitingTxSignRequest(channel, message, state) {
         };
       }
     } else {
-      const signedTx = await appendSignature(message.params.data.signed_tx, tx => options.get(channel).sign(tag, tx, {
+      const signedTx = await appendSignature(message.params.data.signed_tx, async tx => channelOptions.sign(tag, tx, {
         updates: message.params.data.updates
       }));
 
@@ -517,7 +545,7 @@ export async function awaitingTxSignRequest(channel, message, state) {
   return handleUnexpectedMessage(channel, message, state);
 }
 export function awaitingUpdateConflict(channel, message, state) {
-  if (message.error) {
+  if (message.error != null) {
     return {
       handler: awaitingUpdateConflict,
       state
@@ -534,7 +562,7 @@ export function awaitingUpdateConflict(channel, message, state) {
 }
 export async function awaitingShutdownTx(channel, message, state) {
   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',
@@ -549,7 +577,7 @@ export async function awaitingShutdownTx(channel, message, 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 => state.sign(tx));
     send(channel, {
       jsonrpc: '2.0',
       method: 'channels.shutdown_sign',
@@ -603,7 +631,7 @@ export async function awaitingWithdrawTx(channel, message, state) {
       sign
     } = state;
 
-    if (message.params.data.tx) {
+    if (message.params.data.tx != null) {
       const signedTx = await sign(message.params.data.tx, {
         updates: message.params.data.updates
       });
@@ -620,7 +648,7 @@ export async function awaitingWithdrawTx(channel, message, state) {
       };
     }
 
-    const signedTx = await appendSignature(message.params.data.signed_tx, tx => sign(tx, {
+    const signedTx = await appendSignature(message.params.data.signed_tx, async tx => sign(tx, {
       updates: message.params.data.updates
     }));
 
@@ -657,10 +685,9 @@ export async function awaitingWithdrawTx(channel, message, state) {
 }
 export function awaitingWithdrawCompletion(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
-    if (state.onOnChainTx) {
-      state.onOnChainTx(message.params.data.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
@@ -668,16 +695,16 @@ export function awaitingWithdrawCompletion(channel, message, state) {
   }
 
   if (message.method === 'channels.info') {
-    if (['own_withdraw_locked', 'withdraw_locked'].includes(message.params.data.event)) {
-      const callback = {
-        own_withdraw_locked: state.onOwnWithdrawLocked,
-        withdraw_locked: state.onWithdrawLocked
-      }[message.params.data.event];
+    var _context2;
 
-      if (callback) {
-        callback();
-      }
+    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
@@ -726,7 +753,7 @@ export async function awaitingDepositTx(channel, message, state) {
       sign
     } = state;
 
-    if (message.params.data.tx) {
+    if (message.params.data.tx != null) {
       const signedTx = await sign(message.params.data.tx, {
         updates: message.params.data.updates
       });
@@ -743,7 +770,7 @@ export async function awaitingDepositTx(channel, message, state) {
       };
     }
 
-    const signedTx = await appendSignature(message.params.data.signed_tx, tx => sign(tx, {
+    const signedTx = await appendSignature(message.params.data.signed_tx, async tx => sign(tx, {
       updates: message.params.data.updates
     }));
 
@@ -780,10 +807,9 @@ export async function awaitingDepositTx(channel, message, state) {
 }
 export function awaitingDepositCompletion(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
-    if (state.onOnChainTx) {
-      state.onOnChainTx(message.params.data.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
@@ -791,16 +817,16 @@ export function awaitingDepositCompletion(channel, message, state) {
   }
 
   if (message.method === 'channels.info') {
-    if (['own_deposit_locked', 'deposit_locked'].includes(message.params.data.event)) {
-      const callback = {
-        own_deposit_locked: state.onOwnDepositLocked,
-        deposit_locked: state.onDepositLocked
-      }[message.params.data.event];
+    var _context3;
 
-      if (callback) {
-        callback();
-      }
+    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
@@ -845,7 +871,7 @@ export function awaitingDepositCompletion(channel, message, state) {
 }
 export async function awaitingNewContractTx(channel, message, state) {
   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',
@@ -860,7 +886,7 @@ export async function awaitingNewContractTx(channel, message, 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 => state.sign(tx));
 
     if (typeof signedTx === 'string') {
       send(channel, {
@@ -894,23 +920,31 @@ export async function awaitingNewContractTx(channel, message, 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).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
-    };
+    } = 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') {
@@ -939,7 +973,7 @@ export function awaitingNewContractCompletion(channel, message, state) {
 }
 export async function awaitingCallContractUpdateTx(channel, message, state) {
   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
       });
@@ -956,7 +990,7 @@ export async function awaitingCallContractUpdateTx(channel, message, 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 => state.sign(tx, {
       updates: message.params.data.updates
     }));
 
@@ -993,7 +1027,7 @@ export async function awaitingCallContractUpdateTx(channel, message, state) {
 }
 export async function awaitingCallContractForceProgressUpdate(channel, message, state) {
   if (message.method === 'channels.sign.force_progress_tx') {
-    const signedTx = await appendSignature(message.params.data.signed_tx, tx => state.sign(tx, {
+    const signedTx = await appendSignature(message.params.data.signed_tx, async tx => state.sign(tx, {
       updates: message.params.data.updates
     }));
     send(channel, {
@@ -1013,10 +1047,9 @@ export async function awaitingCallContractForceProgressUpdate(channel, message,
 }
 export function awaitingForceProgressCompletion(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
-    if (state.onOnChainTx) {
-      state.onOnChainTx(message.params.data);
-    }
+    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
@@ -1065,7 +1098,7 @@ export function awaitingCallContractCompletion(channel, message, state) {
 
   return handleUnexpectedMessage(channel, message, state);
 }
-export function awaitingCallsPruned(channels, message, state) {
+export function awaitingCallsPruned(_channels, message, state) {
   if (message.method === 'channels.calls_pruned.reply') {
     state.resolve();
     return {
@@ -1078,8 +1111,8 @@ export function awaitingCallsPruned(channels, message, state) {
     handler: channelClosed
   };
 }
-export function channelClosed(channel, message, state) {
-  if (!state) return {
+export function channelClosed(_channel, message, state) {
+  if (state == null) return {
     handler: channelClosed
   };
   if (message.params.data.event === 'closing') return {