@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/es/channel/{handlers.js → 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,38 +16,35 @@
  *  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_${encodeBase64Check(rlpBinary)}`;
-}
-
-async function appendSignature(tx, signFn) {
+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 { IllegalArgumentError, InsufficientBalanceError, ChannelConnectionError, UnexpectedChannelMessageError } from "../utils/errors.mjs";
+import { TX_TYPE } from "../tx/builder/schema.mjs";
+export async function appendSignature(tx, signFn) {
   const {
     signatures,
     encodedTx
-  } = unpackTx(tx).tx;
-  const result = await signFn(encodeRlpTx(encodedTx.rlpEncoded));
+  } = 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({
+      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) {
-    state.reject(Object.assign(new Error(`Unexpected message received:\n\n${JSON.stringify(message)}`), {
+function handleUnexpectedMessage(_channel, message, state) {
+  if ((state === null || state === void 0 ? void 0 : state.reject) != null) {
+    state.reject(Object.assign(new UnexpectedChannelMessageError(`Unexpected message received:\n\n${JSON.stringify(message)}`), {
       wsMessage: message
     }));
   }
@@ -55,13 +54,17 @@ function handleUnexpectedMessage(channel, message, state) {
   };
 }
 
-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
       };
@@ -86,7 +89,9 @@ export function awaitingConnection(channel, message, state) {
   }
 
   if (message.method === 'channels.error') {
-    emit(channel, 'error', new Error(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
     };
@@ -105,72 +110,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 => await 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
       };
@@ -187,7 +201,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 {
@@ -195,7 +209,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 {
@@ -290,7 +304,7 @@ export async function channelOpen(channel, message, state) {
       };
 
     case 'channels.sign.shutdown_sign_ack':
-      return awaitingTxSignRequest(channel, message, state);
+      return await awaitingTxSignRequest(channel, message, state);
   }
 }
 
@@ -304,7 +318,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
       });
@@ -321,7 +335,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 => await sign(tx, {
       updates: message.params.data.updates
     }));
 
@@ -355,23 +369,27 @@ 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) {
+  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)) {
-      state.reject(new Error('Insufficient balance'));
-    } else if (data.find(i => i.code === 1002)) {
-      state.reject(new Error('Amount cannot be negative'));
+    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 {
@@ -437,8 +455,8 @@ export function awaitingOffChainUpdate(channel, message, state) {
     }
   }
 
-  if (message.error) {
-    state.reject(new Error(message.error.message));
+  if (message.error != null) {
+    state.reject(new ChannelConnectionError(message.error.message));
     return {
       handler: channelOpen
     };
@@ -447,15 +465,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}`,
@@ -468,7 +489,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 => await channelOptions.sign(tag, tx, {
         updates: message.params.data.updates
       }));
 
@@ -519,7 +540,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
@@ -536,7 +557,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',
@@ -551,7 +572,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 => await state.sign(tx));
     send(channel, {
       jsonrpc: '2.0',
       method: 'channels.shutdown_sign',
@@ -591,7 +612,7 @@ export function awaitingLeave(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
     };
@@ -605,7 +626,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
       });
@@ -622,7 +643,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 => await sign(tx, {
       updates: message.params.data.updates
     }));
 
@@ -659,7 +680,7 @@ export async function awaitingWithdrawTx(channel, message, state) {
 }
 export function awaitingWithdrawCompletion(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
-    if (state.onOnChainTx) {
+    if (state.onOnChainTx != null) {
       state.onOnChainTx(message.params.data.tx);
     }
 
@@ -670,13 +691,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 = {
+    var _context2;
+
+    if (_includesInstanceProperty(_context2 = ['own_withdraw_locked', 'withdraw_locked']).call(_context2, message.params.data.event)) {
+      const callbacks = {
         own_withdraw_locked: state.onOwnWithdrawLocked,
         withdraw_locked: state.onWithdrawLocked
-      }[message.params.data.event];
+      };
+      const callback = callbacks[message.params.data.event];
 
-      if (callback) {
+      if (callback != null) {
         callback();
       }
 
@@ -728,7 +752,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
       });
@@ -745,7 +769,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 => await sign(tx, {
       updates: message.params.data.updates
     }));
 
@@ -782,7 +806,7 @@ export async function awaitingDepositTx(channel, message, state) {
 }
 export function awaitingDepositCompletion(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
-    if (state.onOnChainTx) {
+    if (state.onOnChainTx != null) {
       state.onOnChainTx(message.params.data.tx);
     }
 
@@ -793,13 +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 = {
+    var _context3;
+
+    if (_includesInstanceProperty(_context3 = ['own_deposit_locked', 'deposit_locked']).call(_context3, message.params.data.event)) {
+      const callbacks = {
         own_deposit_locked: state.onOwnDepositLocked,
         deposit_locked: state.onDepositLocked
-      }[message.params.data.event];
+      };
+      const callback = callbacks[message.params.data.event];
 
-      if (callback) {
+      if (callback != null) {
         callback();
       }
 
@@ -847,7 +874,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',
@@ -862,7 +889,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 => await state.sign(tx));
 
     if (typeof signedTx === 'string') {
       send(channel, {
@@ -896,23 +923,29 @@ 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, TX_TYPE.signed).tx.encodedTx.tx;
+
+    if ((channelOptions === null || channelOptions === void 0 ? void 0 : channelOptions.role) != null) {
+      const role = channelOptions.role === 'initiator' ? 'initiatorId' : channelOptions.role === 'responder' ? 'responderId' : null;
+
+      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') {
@@ -941,7 +974,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
       });
@@ -958,7 +991,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 => await state.sign(tx, {
       updates: message.params.data.updates
     }));
 
@@ -995,7 +1028,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 => await state.sign(tx, {
       updates: message.params.data.updates
     }));
     send(channel, {
@@ -1015,7 +1048,7 @@ export async function awaitingCallContractForceProgressUpdate(channel, message,
 }
 export function awaitingForceProgressCompletion(channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
-    if (state.onOnChainTx) {
+    if (state.onOnChainTx != null) {
       state.onOnChainTx(message.params.data);
     }
 
@@ -1067,7 +1100,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 {
@@ -1075,13 +1108,13 @@ export function awaitingCallsPruned(channels, message, state) {
     };
   }
 
-  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 {
+export function channelClosed(_channel, message, state) {
+  if (state == null) return {
     handler: channelClosed
   };
   if (message.params.data.event === 'closing') return {
@@ -1109,4 +1142,4 @@ export function channelClosed(channel, message, state) {
     state
   };
 }
-//# sourceMappingURL=handlers.js.map
+//# sourceMappingURL=handlers.mjs.map