@aeternity/aepp-sdk 8.2.1 → 10.0.0

package/src/tx/tx.js

@@ -22,34 +22,35 @@
  * @example import { Transaction } from '@aeternity/aepp-sdk'
  */
 
-import * as R from 'ramda'
-
 import ChainNode from '../chain/node'
 import Tx from './'
-
-import { buildTx, calculateFee } from './builder'
+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'
 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 +58,195 @@ 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 }) {
+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))
+async function contractCallTx ({
+  callerId, contractId, abiVersion, amount, gas, gasPrice = MIN_GAS_PRICE, callData
+}) {
+  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))
+async function oracleRegisterTx ({
+  accountId, queryFormat, responseFormat, queryFee, oracleTtl, abiVersion = ABI_VERSIONS.NO_ABI
+}) {
+  // 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 +264,18 @@ 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 +283,18 @@ 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 +312,34 @@ 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
-    }
-    : await this.api.postOracleRespond({ oracleId, responseTtl, queryId, response, fee: parseInt(fee), ttl, nonce })
+        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 +347,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 +357,21 @@ 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 +379,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 +389,21 @@ 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 +411,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,52 +421,68 @@ 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 }) {
+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)
   }
 }
 
+async function payingForTx ({ tx, payerId, ...args }) {
+  const params = { tx: unpackTx(tx), payerId }
+  const { fee, nonce } = await this.prepareTxParams(TX_TYPE.payingFor, {
+    ...params, ...args, senderId: payerId
+  })
+  return buildTx({ ...params, ...args, fee, nonce }, TX_TYPE.payingFor).tx
+}
+
 /**
  * Validated vm/abi version or get default based on transaction type and NODE version
  *
@@ -425,14 +497,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 }
 }
 
 /**
@@ -462,7 +536,8 @@ async function calculateTtl (ttl = TX_TTL, relative = true) {
  */
 async function getAccountNonce (accountId, nonce) {
   if (nonce) return nonce
-  const { nonce: accountNonce } = await this.api.getAccountByPubkey(accountId).catch(() => ({ nonce: 0 }))
+  const { nonce: accountNonce } = await this.api.getAccountByPubkey(accountId)
+    .catch(() => ({ nonce: 0 }))
   return accountNonce + 1
 }
 
@@ -473,16 +548,19 @@ 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 }
 }
 
@@ -535,6 +613,7 @@ const Transaction = ChainNode.compose(Tx, {
     channelSettleTx,
     channelSnapshotSoloTx,
     gaAttachTx,
+    payingForTx,
     getAccountNonce,
     getVmVersion
   }