@aeternity/aepp-sdk 9.0.1 → 10.0.0-beta.1

package/src/tx/tx.js

@@ -22,11 +22,8 @@
  * @example import { Transaction } from '@aeternity/aepp-sdk'
  */
 
-import * as R from 'ramda'
-
 import ChainNode from '../chain/node'
 import Tx from './'
-
 import { buildTx, calculateFee, unpackTx } from './builder'
 import { ABI_VERSIONS, MIN_GAS_PRICE, PROTOCOL_VM_ABI, TX_TYPE, TX_TTL } from './builder/schema'
 import { buildContractId } from './builder/helpers'
@@ -34,22 +31,24 @@ import { TxObject } from './tx-object'
 
 async function spendTx ({ senderId, recipientId, amount, payload = '' }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.spend, { senderId, ...R.head(arguments), payload })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.spend, { senderId, ...arguments[0], payload })
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: R.merge(R.head(arguments), {
-          recipientId,
-          senderId,
-          nonce,
-          ttl,
-          payload
-        }),
-        type: TX_TYPE.spend
-      }).encodedTx
-    }
-    : await this.api.postSpend(R.merge(R.head(arguments), {
+        tx: TxObject({
+          params: {
+            ...arguments[0],
+            recipientId,
+            senderId,
+            nonce,
+            ttl,
+            payload
+          },
+          type: TX_TYPE.spend
+        }).encodedTx
+      }
+    : await this.api.postSpend({
+      ...arguments[0],
       amount: parseInt(amount),
       recipientId,
       senderId,
@@ -57,160 +56,161 @@ async function spendTx ({ senderId, recipientId, amount, payload = '' }) {
       ttl,
       fee: parseInt(fee),
       payload
-    }))
+    })
 
   return tx
 }
 
 async function namePreclaimTx ({ accountId, commitmentId }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.namePreClaim, { senderId: accountId, ...R.head(arguments) })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.namePreClaim, { senderId: accountId, ...arguments[0] })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: R.merge(R.head(arguments), { nonce, ttl, fee }),
-        type: TX_TYPE.namePreClaim
-      }).encodedTx
-    }
-    : await this.api.postNamePreclaim(R.merge(R.head(arguments), { nonce, ttl, fee: parseInt(fee) }))
+        tx: TxObject({
+          params: { ...arguments[0], nonce, ttl, fee },
+          type: TX_TYPE.namePreClaim
+        }).encodedTx
+      }
+    : await this.api.postNamePreclaim({ ...arguments[0], nonce, ttl, fee: parseInt(fee) })
 
   return tx
 }
 
 async function nameClaimTx ({ accountId, name, nameSalt, vsn = 2 }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.nameClaim, { senderId: accountId, ...R.head(arguments), vsn })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.nameClaim, { senderId: accountId, ...arguments[0], vsn })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: R.merge(R.head(arguments), { nonce, ttl, fee, vsn }),
-        type: TX_TYPE.nameClaim
-      }).encodedTx
-    }
-    : await this.api.postNameClaim(R.merge(R.head(arguments), { nonce, ttl, fee: parseInt(fee) }))
+        tx: TxObject({
+          params: { ...arguments[0], nonce, ttl, fee, vsn },
+          type: TX_TYPE.nameClaim
+        }).encodedTx
+      }
+    : await this.api.postNameClaim({ ...arguments[0], nonce, ttl, fee: parseInt(fee) })
 
   return tx
 }
 
 async function nameTransferTx ({ accountId, nameId, recipientId }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.nameTransfer, { senderId: accountId, ...R.head(arguments) })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.nameTransfer, { senderId: accountId, ...arguments[0] })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: R.merge(R.head(arguments), { recipientId, nonce, ttl, fee }),
-        type: TX_TYPE.nameTransfer
-      }).encodedTx
-    }
-    : await this.api.postNameTransfer(R.merge(R.head(arguments), { recipientId, nonce, ttl, fee: parseInt(fee) }))
+        tx: TxObject({
+          params: { ...arguments[0], recipientId, nonce, ttl, fee },
+          type: TX_TYPE.nameTransfer
+        }).encodedTx
+      }
+    : await this.api.postNameTransfer({ ...arguments[0], recipientId, nonce, ttl, fee: parseInt(fee) })
 
   return tx
 }
 
 async function nameUpdateTx ({ accountId, nameId, nameTtl, pointers, clientTtl }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.nameUpdate, { senderId: accountId, ...R.head(arguments) })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.nameUpdate, { senderId: accountId, ...arguments[0] })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: R.merge(R.head(arguments), { nonce, ttl, fee }),
-        type: TX_TYPE.nameUpdate
-      }).encodedTx
-    }
-    : await this.api.postNameUpdate(R.merge(R.head(arguments), { nonce, ttl, fee: parseInt(fee) }))
+        tx: TxObject({
+          params: { ...arguments[0], nonce, ttl, fee },
+          type: TX_TYPE.nameUpdate
+        }).encodedTx
+      }
+    : await this.api.postNameUpdate({ ...arguments[0], nonce, ttl, fee: parseInt(fee) })
 
   return tx
 }
 
 async function nameRevokeTx ({ accountId, nameId }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.nameRevoke, { senderId: accountId, ...R.head(arguments) })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.nameRevoke, { senderId: accountId, ...arguments[0] })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: R.merge(R.head(arguments), { nonce, ttl, fee }),
-        type: TX_TYPE.nameRevoke
-      }).encodedTx
-    }
-    : await this.api.postNameRevoke(R.merge(R.head(arguments), { nonce, ttl, fee: parseInt(fee) }))
+        tx: TxObject({
+          params: { ...arguments[0], nonce, ttl, fee },
+          type: TX_TYPE.nameRevoke
+        }).encodedTx
+      }
+    : await this.api.postNameRevoke({ ...arguments[0], nonce, ttl, fee: parseInt(fee) })
 
   return tx
 }
 
 async function contractCreateTx ({ ownerId, code, vmVersion, abiVersion, deposit, amount, gas, gasPrice = MIN_GAS_PRICE, callData }) {
   // Get VM_ABI version
-  const ctVersion = this.getVmVersion(TX_TYPE.contractCreate, R.head(arguments))
+  const ctVersion = this.getVmVersion(TX_TYPE.contractCreate, arguments[0])
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.contractCreate, { senderId: ownerId, ...R.head(arguments), ctVersion, gasPrice })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.contractCreate, { senderId: ownerId, ...arguments[0], ctVersion, gasPrice })
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   return this.nativeMode
     ? {
-      tx: TxObject({
-        params: R.merge(R.head(arguments), { nonce, ttl, fee, ctVersion, gasPrice }),
-        type: TX_TYPE.contractCreate
-      }).encodedTx,
-      contractId: buildContractId(ownerId, nonce)
-    }
-    : this.api.postContractCreate(R.merge(R.head(arguments), { nonce, ttl, fee: parseInt(fee), gas: parseInt(gas), gasPrice, vmVersion: ctVersion.vmVersion, abiVersion: ctVersion.abiVersion }))
+        tx: TxObject({
+          params: { ...arguments[0], nonce, ttl, fee, ctVersion, gasPrice },
+          type: TX_TYPE.contractCreate
+        }).encodedTx,
+        contractId: buildContractId(ownerId, nonce)
+      }
+    : this.api.postContractCreate({ ...arguments[0], nonce, ttl, fee: parseInt(fee), gas: parseInt(gas), gasPrice, vmVersion: ctVersion.vmVersion, abiVersion: ctVersion.abiVersion })
 }
 
 async function contractCallTx ({ callerId, contractId, abiVersion, amount, gas, gasPrice = MIN_GAS_PRICE, callData }) {
-  const ctVersion = this.getVmVersion(TX_TYPE.contractCall, R.head(arguments))
+  const ctVersion = this.getVmVersion(TX_TYPE.contractCall, arguments[0])
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.contractCall, { senderId: callerId, ...R.head(arguments), gasPrice, abiVersion: ctVersion.abiVersion })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.contractCall, { senderId: callerId, ...arguments[0], gasPrice, abiVersion: ctVersion.abiVersion })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: R.merge(R.head(arguments), { nonce, ttl, fee, abiVersion: ctVersion.abiVersion, gasPrice }),
-        type: TX_TYPE.contractCall
-      }).encodedTx
-    }
-    : await this.api.postContractCall(R.merge(R.head(arguments), {
+        tx: TxObject({
+          params: { ...arguments[0], nonce, ttl, fee, abiVersion: ctVersion.abiVersion, gasPrice },
+          type: TX_TYPE.contractCall
+        }).encodedTx
+      }
+    : await this.api.postContractCall({
+      ...arguments[0],
       nonce,
       ttl,
       fee: parseInt(fee),
       gas: parseInt(gas),
       gasPrice,
       abiVersion: ctVersion.abiVersion
-    }))
+    })
 
   return tx
 }
 
 async function oracleRegisterTx ({ accountId, queryFormat, responseFormat, queryFee, oracleTtl, abiVersion = ABI_VERSIONS.NO_ABI }) {
-  // const { abiVersion: abi } = this.getVmVersion(TX_TYPE.oracleRegister, R.head(arguments))
+  // const { abiVersion: abi } = this.getVmVersion(TX_TYPE.oracleRegister, arguments[0])
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.oracleRegister, { senderId: accountId, ...R.head(arguments), abiVersion })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.oracleRegister, { senderId: accountId, ...arguments[0], abiVersion })
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: {
-          accountId,
-          queryFee,
-          abiVersion,
-          fee,
-          oracleTtl,
-          nonce,
-          ttl,
-          queryFormat,
-          responseFormat
-        },
-        type: TX_TYPE.oracleRegister
-      }).encodedTx
-    }
+        tx: TxObject({
+          params: {
+            accountId,
+            queryFee,
+            abiVersion,
+            fee,
+            oracleTtl,
+            nonce,
+            ttl,
+            queryFormat,
+            responseFormat
+          },
+          type: TX_TYPE.oracleRegister
+        }).encodedTx
+      }
     : await this.api.postOracleRegister({
       accountId,
       queryFee,
@@ -228,16 +228,16 @@ async function oracleRegisterTx ({ accountId, queryFormat, responseFormat, query
 
 async function oracleExtendTx ({ oracleId, callerId, oracleTtl }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.oracleExtend, { senderId: callerId, ...R.head(arguments) })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.oracleExtend, { senderId: callerId, ...arguments[0] })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: { oracleId, fee, oracleTtl, nonce, ttl },
-        type: TX_TYPE.oracleExtend
-      }).encodedTx
-    }
+        tx: TxObject({
+          params: { oracleId, fee, oracleTtl, nonce, ttl },
+          type: TX_TYPE.oracleExtend
+        }).encodedTx
+      }
     : await this.api.postOracleExtend({ oracleId, fee: parseInt(fee), oracleTtl, nonce, ttl })
 
   return tx
@@ -245,16 +245,16 @@ async function oracleExtendTx ({ oracleId, callerId, oracleTtl }) {
 
 async function oraclePostQueryTx ({ oracleId, responseTtl, query, queryTtl, queryFee, senderId }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.oracleQuery, { senderId, ...R.head(arguments) })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.oracleQuery, { senderId, ...arguments[0] })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: { oracleId, responseTtl, query, queryTtl, fee, queryFee, ttl, nonce, senderId },
-        type: TX_TYPE.oracleQuery
-      }).encodedTx
-    }
+        tx: TxObject({
+          params: { oracleId, responseTtl, query, queryTtl, fee, queryFee, ttl, nonce, senderId },
+          type: TX_TYPE.oracleQuery
+        }).encodedTx
+      }
     : await this.api.postOracleQuery({
       oracleId,
       responseTtl,
@@ -272,27 +272,28 @@ async function oraclePostQueryTx ({ oracleId, responseTtl, query, queryTtl, quer
 
 async function oracleRespondTx ({ oracleId, callerId, responseTtl, queryId, response }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.oracleResponse, { senderId: callerId, ...R.head(arguments) })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.oracleResponse, { senderId: callerId, ...arguments[0] })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
     ? {
-      tx: TxObject({
-        params: { oracleId, responseTtl, queryId, response, fee, ttl, nonce },
-        type: TX_TYPE.oracleResponse
-      }).encodedTx
-    }
+        tx: TxObject({
+          params: { oracleId, responseTtl, queryId, response, fee, ttl, nonce },
+          type: TX_TYPE.oracleResponse
+        }).encodedTx
+      }
     : await this.api.postOracleRespond({ oracleId, responseTtl, queryId, response, fee: parseInt(fee), ttl, nonce })
   return tx
 }
 
 async function channelCloseSoloTx ({ channelId, fromId, payload, poi }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.channelCloseSolo, { senderId: fromId, ...R.head(arguments), payload })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.channelCloseSolo, { senderId: fromId, ...arguments[0], payload })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
-    ? buildTx(R.merge(R.head(arguments), {
+    ? buildTx({
+      ...arguments[0],
       channelId,
       fromId,
       payload,
@@ -300,8 +301,9 @@ async function channelCloseSoloTx ({ channelId, fromId, payload, poi }) {
       ttl,
       fee,
       nonce
-    }), TX_TYPE.channelCloseSolo)
-    : await this.api.postChannelCloseSolo(R.merge(R.head(arguments), {
+    }, TX_TYPE.channelCloseSolo)
+    : await this.api.postChannelCloseSolo({
+      ...arguments[0],
       channelId,
       fromId,
       payload,
@@ -309,18 +311,19 @@ async function channelCloseSoloTx ({ channelId, fromId, payload, poi }) {
       ttl,
       fee: parseInt(fee),
       nonce
-    }))
+    })
 
   return tx
 }
 
 async function channelSlashTx ({ channelId, fromId, payload, poi }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.channelSlash, { senderId: fromId, ...R.head(arguments), payload })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.channelSlash, { senderId: fromId, ...arguments[0], payload })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
-    ? buildTx(R.merge(R.head(arguments), {
+    ? buildTx({
+      ...arguments[0],
       channelId,
       fromId,
       payload,
@@ -328,8 +331,9 @@ async function channelSlashTx ({ channelId, fromId, payload, poi }) {
       ttl,
       fee,
       nonce
-    }), TX_TYPE.channelSlash)
-    : await this.api.postChannelSlash(R.merge(R.head(arguments), {
+    }, TX_TYPE.channelSlash)
+    : await this.api.postChannelSlash({
+      ...arguments[0],
       channelId,
       fromId,
       payload,
@@ -337,18 +341,19 @@ async function channelSlashTx ({ channelId, fromId, payload, poi }) {
       ttl,
       fee: parseInt(fee),
       nonce
-    }))
+    })
 
   return tx
 }
 
 async function channelSettleTx ({ channelId, fromId, initiatorAmountFinal, responderAmountFinal }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.channelSettle, { senderId: fromId, ...R.head(arguments) })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.channelSettle, { senderId: fromId, ...arguments[0] })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
-    ? buildTx(R.merge(R.head(arguments), {
+    ? buildTx({
+      ...arguments[0],
       channelId,
       fromId,
       initiatorAmountFinal,
@@ -356,8 +361,9 @@ async function channelSettleTx ({ channelId, fromId, initiatorAmountFinal, respo
       ttl,
       fee,
       nonce
-    }), TX_TYPE.channelSettle)
-    : await this.api.postChannelSettle(R.merge(R.head(arguments), {
+    }, TX_TYPE.channelSettle)
+    : await this.api.postChannelSettle({
+      ...arguments[0],
       channelId,
       fromId,
       initiatorAmountFinal: parseInt(initiatorAmountFinal),
@@ -365,46 +371,48 @@ async function channelSettleTx ({ channelId, fromId, initiatorAmountFinal, respo
       ttl,
       fee: parseInt(fee),
       nonce
-    }))
+    })
 
   return tx
 }
 
 async function channelSnapshotSoloTx ({ channelId, fromId, payload }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.channelSnapshotSolo, { senderId: fromId, ...R.head(arguments), payload })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.channelSnapshotSolo, { senderId: fromId, ...arguments[0], payload })
 
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   const { tx } = this.nativeMode
-    ? buildTx(R.merge(R.head(arguments), {
+    ? buildTx({
+      ...arguments[0],
       channelId,
       fromId,
       payload,
       ttl,
       fee,
       nonce
-    }), TX_TYPE.channelSnapshotSolo)
-    : await this.api.postChannelSnapshotSolo(R.merge(R.head(arguments), {
+    }, TX_TYPE.channelSnapshotSolo)
+    : await this.api.postChannelSnapshotSolo({
+      ...arguments[0],
       channelId,
       fromId,
       payload,
       ttl,
       fee: parseInt(fee),
       nonce
-    }))
+    })
 
   return tx
 }
 
 async function gaAttachTx ({ ownerId, code, vmVersion, abiVersion, authFun, gas, gasPrice = MIN_GAS_PRICE, callData }) {
   // Get VM_ABI version
-  const ctVersion = this.getVmVersion(TX_TYPE.contractCreate, R.head(arguments))
+  const ctVersion = this.getVmVersion(TX_TYPE.contractCreate, arguments[0])
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
-  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.gaAttach, { senderId: ownerId, ...R.head(arguments), ctVersion, gasPrice })
+  const { fee, ttl, nonce } = await this.prepareTxParams(TX_TYPE.gaAttach, { senderId: ownerId, ...arguments[0], ctVersion, gasPrice })
   // Build transaction using sdk (if nativeMode) or build on `AETERNITY NODE` side
   return {
     tx: TxObject({
-      params: R.merge(R.head(arguments), { nonce, ttl, fee, ctVersion, gasPrice }),
+      params: { ...arguments[0], nonce, ttl, fee, ctVersion, gasPrice },
       type: TX_TYPE.gaAttach
     }).encodedTx,
     contractId: buildContractId(ownerId, nonce)
@@ -433,14 +441,16 @@ function getVmVersion (txType, { vmVersion, abiVersion } = {}) {
   const protocolForTX = supportedProtocol[txType]
   if (!protocolForTX) throw new Error('Not supported tx type')
 
-  const ctVersion = {
-    abiVersion: abiVersion || protocolForTX.abiVersion[0],
-    vmVersion: vmVersion || protocolForTX.vmVersion[0]
+  abiVersion = abiVersion || protocolForTX.abiVersion[0]
+  vmVersion = vmVersion || protocolForTX.vmVersion[0]
+  if (!protocolForTX.vmVersion.includes(vmVersion)) {
+    throw new Error(`VM VERSION ${vmVersion} do not support by this node. Supported: [${protocolForTX.vmVersion}]`)
+  }
+  if (!protocolForTX.abiVersion.includes(abiVersion)) {
+    throw new Error(`ABI VERSION ${abiVersion} do not support by this node. Supported: [${protocolForTX.abiVersion}]`)
   }
-  if (protocolForTX.vmVersion.length && !R.contains(ctVersion.vmVersion, protocolForTX.vmVersion)) throw new Error(`VM VERSION ${ctVersion.vmVersion} do not support by this node. Supported: [${protocolForTX.vmVersion}]`)
-  if (protocolForTX.abiVersion.length && !R.contains(ctVersion.abiVersion, protocolForTX.abiVersion)) throw new Error(`ABI VERSION ${ctVersion.abiVersion} do not support by this node. Supported: [${protocolForTX.abiVersion}]`)
 
-  return ctVersion
+  return { vmVersion, abiVersion }
 }
 
 /**
@@ -481,16 +491,10 @@ async function getAccountNonce (accountId, nonce) {
  * @param {Object} params Object which contains all tx data
  * @return {Object} { ttl, nonce, fee } Object with account nonce, absolute ttl and transaction fee
  */
-async function prepareTxParams (txType, { senderId, nonce: n, ttl: t, fee: f, gas, absoluteTtl, vsn }) {
-  const account = await this.getAccount(senderId).catch(e => ({ nonce: 0 }))
-  // Is GA account
-  if (account.contractId) {
-    n = 0
-  } else {
-    n = n || (account.nonce + 1)
-  }
+async function prepareTxParams (txType, { senderId, nonce: n, ttl: t, fee: f, gas, absoluteTtl, vsn, strategy }) {
+  n = n || (await this.api.getAccountNextNonce(senderId, { strategy }).catch(e => ({ nextNonce: 1 }))).nextNonce
   const ttl = await calculateTtl.call(this, t, !absoluteTtl)
-  const fee = calculateFee(f, txType, { showWarning: this.showWarning, gas, params: R.merge(R.last(arguments), { nonce: n, ttl }), vsn })
+  const fee = calculateFee(f, txType, { showWarning: this.showWarning, gas, params: { ...arguments[1], nonce: n, ttl }, vsn })
   return { fee, ttl, nonce: n }
 }
 

package/src/tx/validator.js

@@ -80,13 +80,15 @@ const validators = [
     const validNonce = account.nonce + 1
     if (nonce === validNonce) return []
     return [{
-      ...nonce < validNonce ? {
-        message: `Nonce ${nonce} is already used, valid nonce is ${validNonce}`,
-        key: 'NonceAlreadyUsed'
-      } : {
-        message: `Nonce ${nonce} is too high, valid nonce is ${validNonce}`,
-        key: 'NonceHigh'
-      },
+      ...nonce < validNonce
+        ? {
+            message: `Nonce ${nonce} is already used, valid nonce is ${validNonce}`,
+            key: 'NonceAlreadyUsed'
+          }
+        : {
+            message: `Nonce ${nonce} is too high, valid nonce is ${validNonce}`,
+            key: 'NonceHigh'
+          },
       checkedKeys: ['nonce']
     }]
   },

package/src/utils/aepp-wallet-communication/rpc/aepp-rpc.js

@@ -5,9 +5,7 @@
  * @export AeppRpc
  * @example import ContentScriptBridge from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc'
  */
-import * as R from 'ramda'
 import { v4 as uuid } from 'uuid'
-
 import Ae from '../../../ae'
 import RpcClient from './rpc-client'
 import { getHandler, message, voidFn } from '../helpers'
@@ -236,7 +234,7 @@ export default Ae.compose({
       if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet')
       if (!this.rpcClient.currentAccount) throw new Error('You are not subscribed for an account.')
       if (options.onAccount && !this.rpcClient.hasAccessToAccount(options.onAccount)) throw new Error(`You do not have access to account ${options.onAccount}`)
-      const opt = R.merge(this.Ae.defaults, options)
+      const opt = { ...this.Ae.defaults, ...options }
       if (!opt.walletBroadcast) {
         const signed = await this.signTransaction(tx, { onAccount: opt.onAccount })
         return this.sendTransaction(signed, opt)

package/src/utils/aepp-wallet-communication/rpc/wallet-rpc.js

@@ -74,7 +74,7 @@ const REQUESTS = {
             }
           }
         } catch (e) {
-          console.error(e)
+          if (instance.debug) console.error(e)
           return { error: ERRORS.internalError({ msg: e.message }) }
         }
       },
@@ -112,7 +112,7 @@ const REQUESTS = {
         try {
           onAcc = resolveOnAccount(instance.addresses(), address, opt)
         } catch (e) {
-          console.error(e)
+          if (instance.debug) console.error(e)
           return { error: ERRORS.internalError({ msg: e.message }) }
         }
         try {
@@ -156,7 +156,7 @@ const REQUESTS = {
             }
           }
         } catch (e) {
-          console.error(e)
+          if (instance.debug) console.error(e)
           return { error: ERRORS.internalError({ msg: e.message }) }
         }
       },

package/src/utils/aepp-wallet-communication/schema.js

@@ -1,6 +1,4 @@
-import * as R from 'ramda'
-
-const asEnum = (array) => R.zipObj(array, array)
+const asEnum = (array) => Object.fromEntries(array.map(a => [a, a]))
 
 export const VERSION = 1
 

package/src/utils/bignumber.ts

@@ -19,7 +19,8 @@ export const parseBigNumber = (number: string | number | BigNumber): string =>
  * @return {Boolean}
  */
 export const isBigNumber = (number: string | number | BigNumber): boolean =>
-  !isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number)
+  ['number', 'object', 'string', 'bigint'].includes(typeof number) &&
+  (!isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number))
 
 /**
  * BigNumber ceil operation

package/src/utils/other.ts

@@ -1,6 +1,6 @@
 import { snakeToPascal, pascalToSnake } from './string'
 
-export const pause = async (duration: number): Promise<undefined> =>
+export const pause = async (duration: number): Promise<void> =>
   await new Promise(resolve => setTimeout(resolve, duration))
 
 export const mapObject = (

package/src/utils/semver-satisfies.ts

@@ -1,6 +1,6 @@
 export default function (version: string, geVersion: string, ltVersion: string): boolean {
   const getComponents = (v: string): number[] => v
-    .split('-')[0].split('.').map(i => +i)
+    .split(/[-+]/)[0].split('.').map(i => +i)
 
   const versionComponents = getComponents(version)
   const geComponents = getComponents(geVersion)